diff --git a/sycl/include/CL/sycl/backend.hpp b/sycl/include/CL/sycl/backend.hpp
index c4a21266ec1f4..9a1fd0e007932 100644
--- a/sycl/include/CL/sycl/backend.hpp
+++ b/sycl/include/CL/sycl/backend.hpp
@@ -66,8 +66,8 @@ using backend_return_t =
     typename backend_traits<Backend>::template return_type<SyclType>;
 
 template <backend BackendName, class SyclObjectT>
-auto get_native(const SyclObjectT &Obj) ->
-    typename interop<BackendName, SyclObjectT>::type {
+auto get_native(const SyclObjectT &Obj)
+    -> backend_return_t<BackendName, SyclObjectT> {
   // TODO use SYCL 2020 exception when implemented
   if (Obj.get_backend() != BackendName)
     throw runtime_error("Backends mismatch", PI_INVALID_OPERATION);
@@ -146,17 +146,18 @@ make_context(
 }
 
 template <backend Backend>
+__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_queue free function")
 typename std::enable_if<
     detail::InteropFeatureSupportMap<Backend>::MakeQueue == true, queue>::type
-make_queue(const typename backend_traits<Backend>::template input_type<queue>
-               &BackendObject,
-           const context &TargetContext, bool KeepOwnership,
-           const async_handler Handler = {}) {
+    make_queue(
+        const typename backend_traits<Backend>::template input_type<queue>
+            &BackendObject,
+        const context &TargetContext, bool KeepOwnership,
+        const async_handler Handler = {}) {
   return detail::make_queue(detail::pi::cast<pi_native_handle>(BackendObject),
                             TargetContext, KeepOwnership, Handler, Backend);
 }
 
-// TODO: remove this version (without ownership) when allowed to break ABI.
 template <backend Backend>
 typename std::enable_if<
     detail::InteropFeatureSupportMap<Backend>::MakeQueue == true, queue>::type
@@ -178,11 +179,13 @@ make_event(const typename backend_traits<Backend>::template input_type<event>
 }
 
 template <backend Backend>
+__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_event free function")
 typename std::enable_if<
     detail::InteropFeatureSupportMap<Backend>::MakeEvent == true, event>::type
-make_event(const typename backend_traits<Backend>::template input_type<event>
-               &BackendObject,
-           const context &TargetContext, bool KeepOwnership) {
+    make_event(
+        const typename backend_traits<Backend>::template input_type<event>
+            &BackendObject,
+        const context &TargetContext, bool KeepOwnership) {
   return detail::make_event(detail::pi::cast<pi_native_handle>(BackendObject),
                             TargetContext, KeepOwnership, Backend);
 }
diff --git a/sycl/include/CL/sycl/backend/opencl.hpp b/sycl/include/CL/sycl/backend/opencl.hpp
index 0c0fc33d3712c..c051ca0f0a4ce 100644
--- a/sycl/include/CL/sycl/backend/opencl.hpp
+++ b/sycl/include/CL/sycl/backend/opencl.hpp
@@ -75,6 +75,7 @@ struct BackendInput<backend::opencl, kernel_bundle<State>> {
 
 template <bundle_state State>
 struct BackendReturn<backend::opencl, kernel_bundle<State>> {
+  // TODO: Per SYCL 2020 this should be std::vector<cl_program>
   using type = cl_program;
 };
 
diff --git a/sycl/include/CL/sycl/context.hpp b/sycl/include/CL/sycl/context.hpp
index 4b2a27f774789..7fd2e1f343580 100644
--- a/sycl/include/CL/sycl/context.hpp
+++ b/sycl/include/CL/sycl/context.hpp
@@ -216,7 +216,7 @@ class __SYCL_EXPORT context {
   ///
   /// \return a native handle, the type of which defined by the backend.
   template <backend BackendName>
-  __SYCL_DEPRECATED("Use SYCL-2020 sycl::get_native free function")
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
   auto get_native() const -> typename interop<BackendName, context>::type {
     return reinterpret_cast<typename interop<BackendName, context>::type>(
         getNative());
diff --git a/sycl/include/CL/sycl/device.hpp b/sycl/include/CL/sycl/device.hpp
index 96f35d24a49de..378a9d8860cda 100644
--- a/sycl/include/CL/sycl/device.hpp
+++ b/sycl/include/CL/sycl/device.hpp
@@ -184,7 +184,7 @@ class __SYCL_EXPORT device {
   ///
   /// \return a native handle, the type of which defined by the backend.
   template <backend BackendName>
-  __SYCL_DEPRECATED("Use SYCL-2020 sycl::get_native free function")
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
   auto get_native() const -> typename interop<BackendName, device>::type {
     return (typename interop<BackendName, device>::type)getNative();
   }
diff --git a/sycl/include/CL/sycl/event.hpp b/sycl/include/CL/sycl/event.hpp
index 70e70d13ad28b..7b01a4bc78540 100644
--- a/sycl/include/CL/sycl/event.hpp
+++ b/sycl/include/CL/sycl/event.hpp
@@ -129,10 +129,12 @@ class __SYCL_EXPORT event {
   ///
   /// \return a native handle, the type of which defined by the backend.
   template <backend BackendName>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
   auto get_native() const -> typename interop<BackendName, event>::type {
     return reinterpret_cast<typename interop<BackendName, event>::type>(
         getNative());
   }
+
 private:
   event(std::shared_ptr<detail::event_impl> EventImpl);
 
diff --git a/sycl/include/CL/sycl/interop_handle.hpp b/sycl/include/CL/sycl/interop_handle.hpp
index 9d1e537a127fd..27d3f6195f638 100644
--- a/sycl/include/CL/sycl/interop_handle.hpp
+++ b/sycl/include/CL/sycl/interop_handle.hpp
@@ -86,7 +86,7 @@ class interop_handle {
   template <backend Backend = backend::opencl>
   backend_return_t<Backend, queue> get_native_queue() const {
 #ifndef __SYCL_DEVICE_ONLY__
-    // TODO: replace the exception thrown below with the SYCL-2020 exception
+    // TODO: replace the exception thrown below with the SYCL 2020 exception
     // with the error code 'errc::backend_mismatch' when those new exceptions
     // are ready to be used.
     if (Backend != get_backend())
@@ -107,7 +107,7 @@ class interop_handle {
   template <backend Backend = backend::opencl>
   backend_return_t<Backend, device> get_native_device() const {
 #ifndef __SYCL_DEVICE_ONLY__
-    // TODO: replace the exception thrown below with the SYCL-2020 exception
+    // TODO: replace the exception thrown below with the SYCL 2020 exception
     // with the error code 'errc::backend_mismatch' when those new exceptions
     // are ready to be used.
     if (Backend != get_backend())
@@ -129,7 +129,7 @@ class interop_handle {
   template <backend Backend = backend::opencl>
   backend_return_t<Backend, context> get_native_context() const {
 #ifndef __SYCL_DEVICE_ONLY__
-    // TODO: replace the exception thrown below with the SYCL-2020 exception
+    // TODO: replace the exception thrown below with the SYCL 2020 exception
     // with the error code 'errc::backend_mismatch' when those new exceptions
     // are ready to be used.
     if (Backend != get_backend())
diff --git a/sycl/include/CL/sycl/kernel_bundle.hpp b/sycl/include/CL/sycl/kernel_bundle.hpp
index 8f67aaf1034f4..21398c232aa9e 100644
--- a/sycl/include/CL/sycl/kernel_bundle.hpp
+++ b/sycl/include/CL/sycl/kernel_bundle.hpp
@@ -25,6 +25,8 @@ __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 // Forward declaration
 template <backend Backend> class backend_traits;
+template <backend Backend, class SyclT>
+auto get_native(const SyclT &Obj) -> backend_return_t<Backend, SyclT>;
 
 namespace detail {
 class kernel_id_impl;
@@ -176,8 +178,8 @@ class __SYCL_EXPORT kernel_bundle_plain {
   void set_specialization_constant_impl(const char *SpecName, void *Value,
                                         size_t Size) noexcept;
 
-  void get_specialization_constant_impl(const char *SpecName, void *Value) const
-      noexcept;
+  void get_specialization_constant_impl(const char *SpecName,
+                                        void *Value) const noexcept;
 
   bool is_specialization_constant_set(const char *SpecName) const noexcept;
 
@@ -308,9 +310,9 @@ class kernel_bundle : public detail::kernel_bundle_plain {
   }
 
   template <backend Backend>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
   std::vector<typename backend_traits<Backend>::template return_type<
-      kernel_bundle<State>>>
-  get_native() {
+      kernel_bundle<State>>> get_native() {
     std::vector<typename backend_traits<Backend>::template return_type<
         kernel_bundle<State>>>
         ReturnValue;
@@ -335,6 +337,25 @@ class kernel_bundle : public detail::kernel_bundle_plain {
 
   template <class T>
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
+
+  template <backend Backend, class SyclT>
+  friend auto get_native(const SyclT &Obj) -> backend_return_t<Backend, SyclT>;
+
+  template <backend Backend>
+  backend_return_t<Backend, kernel_bundle<State>> getNative() const {
+    // NOTE: implementation assumes that the return type is a
+    // derivative of std::vector.
+    backend_return_t<Backend, kernel_bundle<State>> ReturnValue;
+    ReturnValue.reserve(std::distance(begin(), end()));
+
+    for (const device_image<State> &DevImg : *this) {
+      ReturnValue.push_back(
+          detail::pi::cast<typename decltype(ReturnValue)::value_type>(
+              DevImg.getNative()));
+    }
+
+    return ReturnValue;
+  }
 };
 
 /////////////////////////
@@ -604,7 +625,7 @@ __SYCL_EXPORT std::vector<sycl::device> find_device_intersection(
 __SYCL_EXPORT std::shared_ptr<detail::kernel_bundle_impl>
 link_impl(const std::vector<kernel_bundle<bundle_state::object>> &ObjectBundles,
           const std::vector<device> &Devs, const property_list &PropList);
-}
+} // namespace detail
 
 /// \returns a new kernel_bundle which contains the device images from the
 /// ObjectBundles that are translated into one or more new device images of
diff --git a/sycl/include/CL/sycl/platform.hpp b/sycl/include/CL/sycl/platform.hpp
index 16c8d46b0c148..cb2eb2b4d73de 100644
--- a/sycl/include/CL/sycl/platform.hpp
+++ b/sycl/include/CL/sycl/platform.hpp
@@ -116,7 +116,7 @@ class __SYCL_EXPORT platform {
   ///
   /// \return a native handle, the type of which defined by the backend.
   template <backend BackendName>
-  __SYCL_DEPRECATED("Use SYCL-2020 sycl::get_native free function")
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
   auto get_native() const -> typename interop<BackendName, platform>::type {
     return reinterpret_cast<typename interop<BackendName, platform>::type>(
         getNative());
diff --git a/sycl/include/CL/sycl/program.hpp b/sycl/include/CL/sycl/program.hpp
index 6b70b47259af4..7973ff03cf273 100644
--- a/sycl/include/CL/sycl/program.hpp
+++ b/sycl/include/CL/sycl/program.hpp
@@ -365,6 +365,7 @@ class __SYCL_EXPORT __SYCL2020_DEPRECATED(
   ///
   /// \return a native handle, the type of which defined by the backend.
   template <backend BackendName>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
   auto get_native() const -> typename interop<BackendName, program>::type {
     return reinterpret_cast<typename interop<BackendName, program>::type>(
         getNative());
diff --git a/sycl/include/CL/sycl/queue.hpp b/sycl/include/CL/sycl/queue.hpp
index 01f6cbc99015e..0df54566d1b46 100644
--- a/sycl/include/CL/sycl/queue.hpp
+++ b/sycl/include/CL/sycl/queue.hpp
@@ -83,7 +83,7 @@ class AssertInfoCopier;
 static event submitAssertCapture(queue &, event &, queue *,
                                  const detail::code_location &);
 #endif
-}
+} // namespace detail
 
 /// Encapsulates a single SYCL queue which schedules kernels on a SYCL device.
 ///
@@ -1020,6 +1020,7 @@ class __SYCL_EXPORT queue {
   ///
   /// \return a native handle, the type of which defined by the backend.
   template <backend BackendName>
+  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
   auto get_native() const -> typename interop<BackendName, queue>::type {
     return reinterpret_cast<typename interop<BackendName, queue>::type>(
         getNative());
diff --git a/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp b/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp
index cb41cc34447f3..9cc87f424326e 100644
--- a/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp
+++ b/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp
@@ -82,6 +82,30 @@ template <> struct BackendInput<backend::level_zero, context> {
   };
 };
 
+template <> struct BackendInput<backend::level_zero, queue> {
+  using type = struct {
+    interop<backend::level_zero, queue>::type NativeHandle;
+    ext::oneapi::level_zero::ownership Ownership;
+  };
+};
+
+template <> struct BackendInput<backend::level_zero, event> {
+  using type = struct {
+    interop<backend::level_zero, event>::type NativeHandle;
+    ext::oneapi::level_zero::ownership Ownership;
+  };
+};
+
+template <bundle_state State>
+struct BackendInput<backend::level_zero, kernel_bundle<State>> {
+  using type = ze_module_handle_t;
+};
+
+template <bundle_state State>
+struct BackendReturn<backend::level_zero, kernel_bundle<State>> {
+  using type = std::vector<ze_module_handle_t>;
+};
+
 template <> struct BackendReturn<backend::level_zero, kernel> {
   using type = ze_kernel_handle_t;
 };
@@ -90,11 +114,11 @@ template <> struct InteropFeatureSupportMap<backend::level_zero> {
   static constexpr bool MakePlatform = true;
   static constexpr bool MakeDevice = true;
   static constexpr bool MakeContext = true;
-  static constexpr bool MakeQueue = false;
+  static constexpr bool MakeQueue = true;
   static constexpr bool MakeEvent = true;
+  static constexpr bool MakeKernelBundle = true;
   static constexpr bool MakeBuffer = false;
   static constexpr bool MakeKernel = false;
-  static constexpr bool MakeKernelBundle = false;
 };
 } // namespace detail
 
@@ -122,7 +146,7 @@ __SYCL_EXPORT event make_event(const context &Context,
 // Construction of SYCL platform.
 template <typename T, typename detail::enable_if_t<
                           std::is_same<T, platform>::value> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_platform free function")
+__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_platform free function")
 T make(typename interop<backend::level_zero, T>::type Interop) {
   return make_platform(reinterpret_cast<pi_native_handle>(Interop));
 }
@@ -130,7 +154,7 @@ T make(typename interop<backend::level_zero, T>::type Interop) {
 // Construction of SYCL device.
 template <typename T, typename detail::enable_if_t<
                           std::is_same<T, device>::value> * = nullptr>
-__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_device free function")
+__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_device free function")
 T make(const platform &Platform,
        typename interop<backend::level_zero, T>::type Interop) {
   return make_device(Platform, reinterpret_cast<pi_native_handle>(Interop));
@@ -147,7 +171,7 @@ T make(const platform &Platform,
 ///
 template <typename T, typename std::enable_if<
                           std::is_same<T, context>::value>::type * = nullptr>
-__SYCL_DEPRECATED("Use SYCL-2020 sycl::make_context free function")
+__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_context free function")
 T make(const std::vector<device> &DeviceList,
        typename interop<backend::level_zero, T>::type Interop,
        ownership Ownership = ownership::transfer) {
@@ -158,6 +182,7 @@ T make(const std::vector<device> &DeviceList,
 // Construction of SYCL program.
 template <typename T, typename detail::enable_if_t<
                           std::is_same<T, program>::value> * = nullptr>
+__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_kernel_bundle free function")
 T make(const context &Context,
        typename interop<backend::level_zero, T>::type Interop) {
   return make_program(Context, reinterpret_cast<pi_native_handle>(Interop));
@@ -166,6 +191,7 @@ T make(const context &Context,
 // Construction of SYCL queue.
 template <typename T, typename detail::enable_if_t<
                           std::is_same<T, queue>::value> * = nullptr>
+__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_queue free function")
 T make(const context &Context,
        typename interop<backend::level_zero, T>::type Interop,
        ownership Ownership = ownership::transfer) {
@@ -176,6 +202,7 @@ T make(const context &Context,
 // Construction of SYCL event.
 template <typename T, typename detail::enable_if_t<
                           std::is_same<T, event>::value> * = nullptr>
+__SYCL_DEPRECATED("Use SYCL 2020 sycl::make_event free function")
 T make(const context &Context,
        typename interop<backend::level_zero, T>::type Interop,
        ownership Ownership = ownership::transfer) {
@@ -197,9 +224,46 @@ context make_context<backend::level_zero>(
       BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep);
 }
 
+// Specialization of sycl::make_queue for Level-Zero backend.
+template <>
+queue make_queue<backend::level_zero>(
+    const backend_input_t<backend::level_zero, queue> &BackendObject,
+    const context &TargetContext, const async_handler Handler) {
+  return ext::oneapi::level_zero::make_queue(
+      TargetContext,
+      detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
+      BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep);
+}
+
+// Specialization of sycl::make_event for Level-Zero backend.
+template <>
+event make_event<backend::level_zero>(
+    const backend_input_t<backend::level_zero, event> &BackendObject,
+    const context &TargetContext) {
+  return ext::oneapi::level_zero::make_event(
+      TargetContext,
+      detail::pi::cast<pi_native_handle>(BackendObject.NativeHandle),
+      BackendObject.Ownership == ext::oneapi::level_zero::ownership::keep);
+}
+
+// TODO: remove this specialization when generic is changed to call
+// .GetNative() instead of .get_native() member of kernel_bundle.
+template <>
+auto get_native<backend::level_zero>(
+    const kernel_bundle<bundle_state::executable> &Obj)
+    -> backend_return_t<backend::level_zero,
+                        kernel_bundle<bundle_state::executable>> {
+  // TODO use SYCL 2020 exception when implemented
+  if (Obj.get_backend() != backend::level_zero)
+    throw runtime_error("Backends mismatch", PI_INVALID_OPERATION);
+
+  return Obj.template getNative<backend::level_zero>();
+}
+
 namespace __SYCL2020_DEPRECATED("use 'ext::oneapi::level_zero' instead")
     level_zero {
   using namespace ext::oneapi::level_zero;
 }
+
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)
diff --git a/sycl/test/basic_tests/interop-level-zero-2020.cpp b/sycl/test/basic_tests/interop-level-zero-2020.cpp
index 4e40829cffca3..611e7b2a24cff 100644
--- a/sycl/test/basic_tests/interop-level-zero-2020.cpp
+++ b/sycl/test/basic_tests/interop-level-zero-2020.cpp
@@ -5,7 +5,7 @@
 #include <sycl/sycl.hpp>
 // clang-format off
 #include <level_zero/ze_api.h>
-#include <CL/sycl/backend/level_zero.hpp>
+#include <sycl/ext/oneapi/backend/level_zero.hpp>
 // clang-format on
 
 using namespace sycl;
@@ -15,13 +15,13 @@ using namespace sycl;
 // platform,
 // device,
 // context,
+// queue,
+// event,
+// kernel_bundle,
 // TODO:
 // buffer,
 // device_image,
-// event,
 // kernel,
-// kernel_bundle,
-// queue,
 // sampled_image,
 // unsampled_image.
 
@@ -31,6 +31,12 @@ int main() {
   device Device;
   platform Platform = Device.get_info<info::device::platform>();
   context Context(Device);
+  queue Queue(Device);
+  event Event;
+  // expected-warning@+1 {{'program' is deprecated: program class is deprecated, use kernel_bundle instead}}
+  program Program(Context);
+  kernel_bundle<bundle_state::executable> KernelBundle =
+      get_kernel_bundle<bundle_state::executable>(Context);
 
   // 4.5.1.1 For each SYCL runtime class T which supports SYCL application
   // interoperability with the SYCL backend, a specialization of return_type
@@ -46,6 +52,14 @@ int main() {
   backend_traits<backend::ext_oneapi_level_zero>::return_type<device> ZeDevice;
   backend_traits<backend::ext_oneapi_level_zero>::return_type<context>
       ZeContext;
+  backend_traits<backend::ext_oneapi_level_zero>::return_type<queue> ZeQueue;
+  backend_traits<backend::ext_oneapi_level_zero>::return_type<event> ZeEvent;
+  // expected-warning@+1 {{'program' is deprecated: program class is deprecated, use kernel_bundle instead}}
+  backend_traits<backend::ext_oneapi_level_zero>::return_type<program>
+      ZeProgram;
+  backend_traits<backend::ext_oneapi_level_zero>::return_type<
+      kernel_bundle<bundle_state::executable>>
+      ZeKernelBundle;
 
   // 4.5.1.2 For each SYCL runtime class T which supports SYCL application
   // interoperability, a specialization of get_native must be defined, which
@@ -57,17 +71,33 @@ int main() {
   ZeDriver = get_native<backend::ext_oneapi_level_zero>(Platform);
   ZeDevice = get_native<backend::ext_oneapi_level_zero>(Device);
   ZeContext = get_native<backend::ext_oneapi_level_zero>(Context);
+  ZeQueue = get_native<backend::ext_oneapi_level_zero>(Queue);
+  ZeEvent = get_native<backend::ext_oneapi_level_zero>(Event);
+  ZeKernelBundle = get_native<backend::ext_oneapi_level_zero>(KernelBundle);
 
   // Check deprecated
-  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL-2020 sycl::get_native free function}}
-  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL-2020 sycl::get_native free function}}
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
   ZeDriver = Platform.get_native<backend::ext_oneapi_level_zero>();
-  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL-2020 sycl::get_native free function}}
-  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL-2020 sycl::get_native free function}}
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
   ZeDevice = Device.get_native<backend::ext_oneapi_level_zero>();
-  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL-2020 sycl::get_native free function}}
-  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL-2020 sycl::get_native free function}}
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
   ZeContext = Context.get_native<backend::ext_oneapi_level_zero>();
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  ZeQueue = Queue.get_native<backend::ext_oneapi_level_zero>();
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  ZeEvent = Event.get_native<backend::ext_oneapi_level_zero>();
+  // expected-warning@+2 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+1 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  ZeProgram = Program.get_native<backend::ext_oneapi_level_zero>();
+  // expected-warning@+3 {{'get_native' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  // expected-warning@+2 {{'get_native<sycl::backend::ext_oneapi_level_zero>' is deprecated: Use SYCL 2020 sycl::get_native free function}}
+  /*ZeKernelBundle*/ (
+      void)KernelBundle.get_native<backend::ext_oneapi_level_zero>();
 
   // 4.5.1.1 For each SYCL runtime class T which supports SYCL application
   // interoperability with the SYCL backend, a specialization of input_type must
@@ -101,15 +131,33 @@ int main() {
   context InteropContext =
       make_context<backend::ext_oneapi_level_zero>(InteropContextInput);
 
+  queue InteropQueue = make_queue<backend::ext_oneapi_level_zero>(
+      {ZeQueue, ext::oneapi::level_zero::ownership::keep}, Context);
+  event InteropEvent = make_event<backend::ext_oneapi_level_zero>(
+      {ZeEvent, ext::oneapi::level_zero::ownership::keep}, Context);
+  kernel_bundle<bundle_state::executable> InteropKernelBundle =
+      make_kernel_bundle<backend::ext_oneapi_level_zero,
+                         bundle_state::executable>(ZeKernelBundle.front(),
+                                                   Context);
+
   // Check deprecated
-  // expected-warning@+1 {{'make<sycl::platform, nullptr>' is deprecated: Use SYCL-2020 sycl::make_platform free function}}
+  // expected-warning@+1 {{'make<sycl::platform, nullptr>' is deprecated: Use SYCL 2020 sycl::make_platform free function}}
   auto P = ext::oneapi::level_zero::make<platform>(ZeDriver);
-  // expected-warning@+1 {{'make<sycl::device, nullptr>' is deprecated: Use SYCL-2020 sycl::make_device free function}}
+  // expected-warning@+1 {{'make<sycl::device, nullptr>' is deprecated: Use SYCL 2020 sycl::make_device free function}}
   auto D = ext::oneapi::level_zero::make<device>(P, ZeDevice);
-  // expected-warning@+1 {{'make<sycl::context, nullptr>' is deprecated: Use SYCL-2020 sycl::make_context free function}}
+  // expected-warning@+1 {{'make<sycl::context, nullptr>' is deprecated: Use SYCL 2020 sycl::make_context free function}}
   auto C = ext::oneapi::level_zero::make<context>(
       std::vector<device>(1, D), ZeContext,
       ext::oneapi::level_zero::ownership::keep);
+  // expected-warning@+1 {{'make<sycl::queue, nullptr>' is deprecated: Use SYCL 2020 sycl::make_queue free function}}
+  auto Q = ext::oneapi::level_zero::make<queue>(
+      Context, ZeQueue, ext::oneapi::level_zero::ownership::keep);
+  // expected-warning@+1 {{'make<sycl::event, nullptr>' is deprecated: Use SYCL 2020 sycl::make_event free function}}
+  auto E = ext::oneapi::level_zero::make<event>(
+      Context, ZeEvent, ext::oneapi::level_zero::ownership::keep);
+  // expected-warning@+2 {{'program' is deprecated: program class is deprecated, use kernel_bundle instead}}
+  // expected-warning@+1 {{'make<sycl::program, nullptr>' is deprecated: Use SYCL 2020 sycl::make_kernel_bundle free function}}
+  auto PR = ext::oneapi::level_zero::make<program>(Context, ZeProgram);
 
   return 0;
 }