diff --git a/include/oneapi/dpl/iterator b/include/oneapi/dpl/iterator
index 5568292b1c1..45b7e1ccf0f 100644
--- a/include/oneapi/dpl/iterator
+++ b/include/oneapi/dpl/iterator
@@ -56,6 +56,10 @@ using ::std::rbegin;
 using ::std::rend;
 using ::std::reverse_iterator;
 using ::std::size;
+
+using oneapi::dpl::__internal::is_passed_directly_to_device;
+using oneapi::dpl::__internal::is_passed_directly_to_device_v;
+
 } // namespace dpl
 } // namespace oneapi
 namespace dpl = oneapi::dpl;
diff --git a/include/oneapi/dpl/pstl/hetero/dpcpp/utils_ranges_sycl.h b/include/oneapi/dpl/pstl/hetero/dpcpp/utils_ranges_sycl.h
index d11a2676715..6ffbadb8da0 100644
--- a/include/oneapi/dpl/pstl/hetero/dpcpp/utils_ranges_sycl.h
+++ b/include/oneapi/dpl/pstl/hetero/dpcpp/utils_ranges_sycl.h
@@ -200,62 +200,6 @@ struct is_permutation<Iter, ::std::enable_if_t<Iter::is_permutation::value>> : :
 {
 };
 
-//is_passed_directly trait definition; specializations for the oneDPL iterators
-
-template <typename Iter, typename Void = void>
-struct is_passed_directly : ::std::is_pointer<Iter>
-{
-};
-
-//support legacy "is_passed_directly" trait
-template <typename Iter>
-struct is_passed_directly<Iter, ::std::enable_if_t<Iter::is_passed_directly::value>> : ::std::true_type
-{
-};
-
-//support std::vector::iterator with usm host / shared allocator as passed directly
-template <typename Iter>
-struct is_passed_directly<Iter, std::enable_if_t<oneapi::dpl::__internal::__is_known_usm_vector_iter_v<Iter>>>
-    : std::true_type
-{
-};
-
-template <typename Ip>
-struct is_passed_directly<oneapi::dpl::counting_iterator<Ip>> : ::std::true_type
-{
-};
-
-template <>
-struct is_passed_directly<oneapi::dpl::discard_iterator> : ::std::true_type
-{
-};
-
-template <typename Iter>
-struct is_passed_directly<::std::reverse_iterator<Iter>> : is_passed_directly<Iter>
-{
-};
-
-template <typename Iter, typename Unary>
-struct is_passed_directly<oneapi::dpl::transform_iterator<Iter, Unary>> : is_passed_directly<Iter>
-{
-};
-
-template <typename SourceIterator, typename IndexIterator>
-struct is_passed_directly<oneapi::dpl::permutation_iterator<SourceIterator, IndexIterator>>
-    : ::std::conjunction<
-          is_passed_directly<SourceIterator>,
-          is_passed_directly<typename oneapi::dpl::permutation_iterator<SourceIterator, IndexIterator>::IndexMap>>
-{
-};
-
-template <typename... Iters>
-struct is_passed_directly<zip_iterator<Iters...>> : ::std::conjunction<is_passed_directly<Iters>...>
-{
-};
-
-template <typename Iter>
-inline constexpr bool is_passed_directly_v = is_passed_directly<Iter>::value;
-
 // A trait for checking if iterator is heterogeneous or not
 
 template <typename Iter>
@@ -290,7 +234,8 @@ struct is_temp_buff : ::std::false_type
 
 template <typename _Iter>
 struct is_temp_buff<_Iter, ::std::enable_if_t<!is_sycl_iterator_v<_Iter> && !::std::is_pointer_v<_Iter> &&
-                                              !is_passed_directly_v<_Iter>>> : ::std::true_type
+                                              !oneapi::dpl::__internal::is_passed_directly_to_device_v<_Iter>>>
+    : ::std::true_type
 {
 };
 
@@ -550,8 +495,10 @@ struct __get_sycl_range
     }
 
     //specialization for permutation_iterator using USM pointer or direct pass object as source
-    template <sycl::access::mode _LocalAccMode, typename _Iter, typename _Map,
-              ::std::enable_if_t<!is_sycl_iterator_v<_Iter> && is_passed_directly_v<_Iter>, int> = 0>
+    template <
+        sycl::access::mode _LocalAccMode, typename _Iter, typename _Map,
+        ::std::enable_if_t<!is_sycl_iterator_v<_Iter> && oneapi::dpl::__internal::is_passed_directly_to_device_v<_Iter>,
+                           int> = 0>
     auto
     __process_input_iter(oneapi::dpl::permutation_iterator<_Iter, _Map> __first,
                          oneapi::dpl::permutation_iterator<_Iter, _Map> __last)
@@ -568,8 +515,10 @@ struct __get_sycl_range
 
     // specialization for general case, permutation_iterator with base iterator that is not sycl_iterator or
     // passed directly.
-    template <sycl::access::mode _LocalAccMode, typename _Iter, typename _Map,
-              ::std::enable_if_t<!is_sycl_iterator_v<_Iter> && !is_passed_directly_v<_Iter>, int> = 0>
+    template <
+        sycl::access::mode _LocalAccMode, typename _Iter, typename _Map,
+        ::std::enable_if_t<
+            !is_sycl_iterator_v<_Iter> && !oneapi::dpl::__internal::is_passed_directly_to_device_v<_Iter>, int> = 0>
     auto
     __process_input_iter(oneapi::dpl::permutation_iterator<_Iter, _Map> __first,
                          oneapi::dpl::permutation_iterator<_Iter, _Map> __last)
@@ -578,8 +527,8 @@ struct __get_sycl_range
         assert(__n > 0);
 
         //TODO: investigate better method of handling this specifically for fancy_iterators which are composed fully
-        //      of a combination of fancy_iterators, sycl_iterators, and is_passed_directly types.
-        //      Currently this relies on UB because the size of the accessor when handling sycl_iterators
+        //      of a combination of fancy_iterators, sycl_iterators, and is_passed_directly_in_onedpl_device_policies
+        //      types. Currently this relies on UB because the size of the accessor when handling sycl_iterators
         //      in recursion below this level is incorrect.
         auto res_src = this->operator()(__first.base(), __first.base() + 1 /*source size*/);
 
@@ -604,7 +553,8 @@ struct __get_sycl_range
 
     // for raw pointers and direct pass objects (for example, counting_iterator, iterator of USM-containers)
     template <sycl::access::mode _LocalAccMode, typename _Iter>
-    ::std::enable_if_t<is_passed_directly_v<_Iter>, __range_holder<oneapi::dpl::__ranges::guard_view<_Iter>>>
+    ::std::enable_if_t<oneapi::dpl::__internal::is_passed_directly_to_device_v<_Iter>,
+                       __range_holder<oneapi::dpl::__ranges::guard_view<_Iter>>>
     __process_input_iter(_Iter __first, _Iter __last)
     {
         assert(__first < __last);
diff --git a/include/oneapi/dpl/pstl/iterator_impl.h b/include/oneapi/dpl/pstl/iterator_impl.h
index 63ce678e4ae..f5b75592b8b 100644
--- a/include/oneapi/dpl/pstl/iterator_impl.h
+++ b/include/oneapi/dpl/pstl/iterator_impl.h
@@ -75,6 +75,68 @@ struct __make_references
     }
 };
 
+template <typename _Iter, typename _Void = void>
+struct __is_legacy_passed_directly : std::false_type
+{
+};
+
+template <typename _Iter>
+struct __is_legacy_passed_directly<_Iter, ::std::enable_if_t<_Iter::is_passed_directly::value>> : std::true_type
+{
+};
+
+template <typename _T>
+struct __is_reverse_iterator_passed_directly;
+
+template <typename T>
+constexpr auto
+is_passed_directly_in_onedpl_device_policies(const T&)
+{
+    if constexpr (std::is_pointer<std::decay_t<T>>::value)
+        return std::true_type{};
+#if _ONEDPL_BACKEND_SYCL
+    // TODO: hide this better in sycl backend, either all passed directly functions, or just this
+    else if constexpr (oneapi::dpl::__internal::__is_known_usm_vector_iter_v<std::decay_t<T>>)
+        return std::true_type{};
+#endif
+    else if constexpr (__is_legacy_passed_directly<std::decay_t<T>>::value)
+        return std::true_type{};
+    else if constexpr (__is_reverse_iterator_passed_directly<std::decay_t<T>>::value)
+        return std::true_type{};
+    else
+        return std::false_type{};
+}
+
+struct __is_passed_directly_in_onedpl_device_policies_fn
+{
+    template <typename T>
+    constexpr auto
+    operator()(const T& t) const
+    {
+        return is_passed_directly_in_onedpl_device_policies(t);
+    }
+};
+
+inline constexpr __is_passed_directly_in_onedpl_device_policies_fn __is_passed_directly_in_onedpl_device_policies;
+
+template <typename T>
+struct is_passed_directly_to_device
+    : decltype(oneapi::dpl::__internal::__is_passed_directly_in_onedpl_device_policies(std::declval<T>())){};
+
+template <typename T>
+inline constexpr bool is_passed_directly_to_device_v = is_passed_directly_to_device<T>::value;
+
+template <typename _T>
+struct __is_reverse_iterator_passed_directly : std::false_type
+{
+};
+
+template <typename _BaseIter>
+struct __is_reverse_iterator_passed_directly<std::reverse_iterator<_BaseIter>>
+    : oneapi::dpl::__internal::is_passed_directly_to_device<_BaseIter>
+{
+};
+
 //zip_iterator version for forward iterator
 //== and != comparison is performed only on the first element of the tuple
 //
@@ -266,6 +328,9 @@ class counting_iterator
         return !(*this < __it);
     }
 
+    friend std::true_type
+    is_passed_directly_in_onedpl_device_policies(const counting_iterator&);
+
   private:
     _Ip __my_counter_;
 };
@@ -398,6 +463,10 @@ class zip_iterator
         return !(*this < __it);
     }
 
+    friend auto
+    is_passed_directly_in_onedpl_device_policies(const zip_iterator&)
+        -> std::conjunction<oneapi::dpl::__internal::is_passed_directly_to_device<_Types> ...>;
+
   private:
     __it_types __my_it_;
 };
@@ -574,6 +643,9 @@ class transform_iterator
     {
         return __my_unary_func_;
     }
+    friend auto
+    is_passed_directly_in_onedpl_device_policies(const transform_iterator&)
+        -> oneapi::dpl::__internal::is_passed_directly_to_device<_Iter>;
 };
 
 template <typename _Iter, typename _UnaryFunc>
@@ -765,11 +837,16 @@ class permutation_iterator
         return !(*this < it);
     }
 
+    friend auto is_passed_directly_in_onedpl_device_policies(const permutation_iterator&) -> std::conjunction<oneapi::dpl::__internal::is_passed_directly_to_device<SourceIterator>, 
+        oneapi::dpl::__internal::is_passed_directly_to_device<
+        typename oneapi::dpl::permutation_iterator<SourceIterator, _Permutation>::IndexMap>>;
+
   private:
     SourceIterator my_source_it;
     IndexMap my_index;
 };
 
+
 template <typename SourceIterator, typename IndexMap, typename... StartIndex>
 permutation_iterator<SourceIterator, IndexMap>
 make_permutation_iterator(SourceIterator source, IndexMap map, StartIndex... idx)
@@ -927,10 +1004,15 @@ class discard_iterator
         return !(*this < __it);
     }
 
-  private:
+    friend std::true_type
+    is_passed_directly_in_onedpl_device_policies(const discard_iterator&);
+
+    private:
     difference_type __my_position_;
 };
 
+
+
 } // namespace dpl
 } // namespace oneapi
 
diff --git a/test/general/implementation_details/passed_directly.pass.cpp b/test/general/implementation_details/passed_directly.pass.cpp
new file mode 100644
index 00000000000..1cc35aabd78
--- /dev/null
+++ b/test/general/implementation_details/passed_directly.pass.cpp
@@ -0,0 +1,380 @@
+// -*- C++ -*-
+//===-- passed_directly.pass.cpp -----------------------------------------------===//
+//
+// Copyright (C) Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// This file incorporates work covered by the following copyright and permission
+// notice:
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+//
+//===----------------------------------------------------------------------===//
+#include <cstdint>
+#include "support/test_config.h"
+
+#include _PSTL_TEST_HEADER(iterator)
+
+#include "support/utils_device_copyable.h"
+#include "support/utils.h"
+
+#if TEST_DPCPP_BACKEND_PRESENT
+
+struct simple_passed_directly_iterator
+{
+    using iterator_category = std::input_iterator_tag;
+    using value_type = int;
+    using difference_type = std::ptrdiff_t;
+    using pointer = int*;
+    using reference = int&;
+
+    using is_passed_directly = std::true_type;
+
+    simple_passed_directly_iterator(int start = 0) : value(start) {}
+
+    int
+    operator*() const
+    {
+        return value;
+    }
+
+    simple_passed_directly_iterator&
+    operator++()
+    {
+        ++value;
+        return *this;
+    }
+
+    simple_passed_directly_iterator
+    operator++(int)
+    {
+        simple_passed_directly_iterator tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+
+    friend bool
+    operator==(const simple_passed_directly_iterator& a, const simple_passed_directly_iterator& b)
+    {
+        return a.value == b.value;
+    }
+
+    friend bool
+    operator!=(const simple_passed_directly_iterator& a, const simple_passed_directly_iterator& b)
+    {
+        return !(a == b);
+    }
+
+  private:
+    int value;
+};
+
+struct simple_explicitly_not_passed_directly_iterator
+{
+    using iterator_category = std::input_iterator_tag;
+    using value_type = int;
+    using difference_type = std::ptrdiff_t;
+    using pointer = int*;
+    using reference = int&;
+
+    using is_passed_directly = std::false_type;
+
+    simple_explicitly_not_passed_directly_iterator(int start = 0) : value(start) {}
+
+    int
+    operator*() const
+    {
+        return value;
+    }
+
+    simple_explicitly_not_passed_directly_iterator&
+    operator++()
+    {
+        ++value;
+        return *this;
+    }
+
+    simple_explicitly_not_passed_directly_iterator
+    operator++(int)
+    {
+        simple_explicitly_not_passed_directly_iterator tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+
+    friend bool
+    operator==(const simple_explicitly_not_passed_directly_iterator& a,
+               const simple_explicitly_not_passed_directly_iterator& b)
+    {
+        return a.value == b.value;
+    }
+
+    friend bool
+    operator!=(const simple_explicitly_not_passed_directly_iterator& a,
+               const simple_explicitly_not_passed_directly_iterator& b)
+    {
+        return !(a == b);
+    }
+
+  private:
+    int value;
+};
+
+struct simple_implicitly_not_passed_directly_iterator
+{
+    using iterator_category = std::input_iterator_tag;
+    using value_type = int;
+    using difference_type = std::ptrdiff_t;
+    using pointer = int*;
+    using reference = int&;
+
+    using is_passed_directly = std::false_type;
+
+    simple_implicitly_not_passed_directly_iterator(int start = 0) : value(start) {}
+
+    int
+    operator*() const
+    {
+        return value;
+    }
+
+    simple_implicitly_not_passed_directly_iterator&
+    operator++()
+    {
+        ++value;
+        return *this;
+    }
+
+    simple_implicitly_not_passed_directly_iterator
+    operator++(int)
+    {
+        simple_implicitly_not_passed_directly_iterator tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+
+    friend bool
+    operator==(const simple_implicitly_not_passed_directly_iterator& a,
+               const simple_implicitly_not_passed_directly_iterator& b)
+    {
+        return a.value == b.value;
+    }
+
+    friend bool
+    operator!=(const simple_implicitly_not_passed_directly_iterator& a,
+               const simple_implicitly_not_passed_directly_iterator& b)
+    {
+        return !(a == b);
+    }
+
+  private:
+    int value;
+};
+
+namespace custom_user
+{
+template <typename BaseIter>
+struct base_strided_iterator
+{
+    using iterator_category = std::input_iterator_tag;
+    using value_type = typename std::iterator_traits<BaseIter>::value_type;
+
+    base_strided_iterator(BaseIter base, int stride) : base(base), stride(stride) {}
+
+    int
+    operator*() const
+    {
+        return *base;
+    }
+
+    base_strided_iterator&
+    operator++()
+    {
+        std::advance(base, stride);
+        return *this;
+    }
+
+    base_strided_iterator
+    operator++(int)
+    {
+        base_strided_iterator tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+
+    friend bool
+    operator==(const base_strided_iterator& a, const base_strided_iterator& b)
+    {
+        return a.base == b.base;
+    }
+
+    friend bool
+    operator!=(const base_strided_iterator& a, const base_strided_iterator& b)
+    {
+        return !(a == b);
+    }
+
+  private:
+    BaseIter base;
+    int stride;
+};
+
+template <typename BaseIter>
+struct first_strided_iterator : public base_strided_iterator<BaseIter>
+{
+    first_strided_iterator(BaseIter base, int stride) : base_strided_iterator<BaseIter>(base, stride) {}
+};
+
+template <typename BaseIter>
+auto
+is_passed_directly_in_onedpl_device_policies(const first_strided_iterator<BaseIter>&)
+{
+    return oneapi::dpl::is_passed_directly_to_device<BaseIter>{};
+}
+
+template <typename BaseIter>
+struct second_strided_iterator : public base_strided_iterator<BaseIter>
+{
+    second_strided_iterator(BaseIter base, int stride) : base_strided_iterator<BaseIter>(base, stride) {}
+};
+
+template <typename BaseIter>
+auto
+is_passed_directly_in_onedpl_device_policies(const second_strided_iterator<BaseIter>&)
+    -> decltype(oneapi::dpl::is_passed_directly_to_device<BaseIter>{});
+
+template <typename BaseIter>
+struct third_strided_iterator : public base_strided_iterator<BaseIter>
+{
+    third_strided_iterator(BaseIter base, int stride) : base_strided_iterator<BaseIter>(base, stride) {}
+    friend auto
+    is_passed_directly_in_onedpl_device_policies(const third_strided_iterator<BaseIter>&)
+    {
+        return oneapi::dpl::is_passed_directly_to_device<BaseIter>{};
+    }
+};
+
+template <typename BaseIter>
+struct fourth_strided_iterator : public base_strided_iterator<BaseIter>
+{
+    fourth_strided_iterator(BaseIter base, int stride) : base_strided_iterator<BaseIter>(base, stride) {}
+    friend auto
+    is_passed_directly_in_onedpl_device_policies(const fourth_strided_iterator<BaseIter>&)
+        -> oneapi::dpl::is_passed_directly_to_device<BaseIter>;
+};
+
+} // namespace custom_user
+
+template <bool base_passed_directly, typename BaseIter>
+void
+test_with_base_iterator()
+{
+    //test assumption about base iterator passed directly
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<BaseIter> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for base iterator");
+
+    // test wrapping base in transform_iterator
+    using TransformIter = oneapi::dpl::transform_iterator<BaseIter, TestUtils::noop_device_copyable>;
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<TransformIter> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for transform iterator");
+
+    // test wrapping base in permutation_iterator with counting iter
+    using PermutationIter = oneapi::dpl::permutation_iterator<BaseIter, oneapi::dpl::counting_iterator<std::int32_t>>;
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<PermutationIter> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for permutation iterator");
+
+    // test wrapping base in permutation_iter with functor
+    using PermutationIterFunctor = oneapi::dpl::permutation_iterator<BaseIter, TestUtils::noop_device_copyable>;
+    static_assert(
+        oneapi::dpl::is_passed_directly_to_device_v<PermutationIterFunctor> == base_passed_directly,
+        "is_passed_directly_in_onedpl_device_policies is not working correctly for permutation iterator with functor");
+
+    // test wrapping base in zip_iterator
+    using ZipIter = oneapi::dpl::zip_iterator<BaseIter>;
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<ZipIter> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for zip iterator");
+
+    // test wrapping base in zip_iterator with counting_iterator first
+    using ZipIterCounting = oneapi::dpl::zip_iterator<oneapi::dpl::counting_iterator<std::int32_t>, BaseIter>;
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<ZipIterCounting> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for zip iterator with "
+                  "counting iterator first");
+
+    // test wrapping base in zip_iterator with counting_iterator second
+    using ZipIterCounting2 = oneapi::dpl::zip_iterator<BaseIter, oneapi::dpl::counting_iterator<std::int32_t>>;
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<ZipIterCounting2> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for zip iterator with "
+                  "counting iterator first");
+
+    // test wrapping base in reverse_iterator
+    using ReverseIter = std::reverse_iterator<BaseIter>;
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<ReverseIter> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for reverse iterator");
+
+    // test custom user first strided iterator with normal ADL function
+    using FirstStridedIter = custom_user::first_strided_iterator<BaseIter>;
+    static_assert(
+        oneapi::dpl::is_passed_directly_to_device_v<FirstStridedIter> == base_passed_directly,
+        "is_passed_directly_in_onedpl_device_policies is not working correctly for custom user strided iterator");
+
+    // test custom user second strided iterator (no body for is_passed_directly_in_onedpl_device_policies)
+    using SecondStridedIter = custom_user::second_strided_iterator<BaseIter>;
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<SecondStridedIter> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for custom user strided "
+                  "iterator with no body in ADL function definition");
+
+    // test custom user first strided iterator with hidden friend ADL function
+    using ThirdStridedIter = custom_user::third_strided_iterator<BaseIter>;
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<ThirdStridedIter> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for custom user strided "
+                  "iterator with hidden friend ADL function");
+
+    // test custom user first strided iterator with hidden friend ADL function without body
+    using FourthStridedIter = custom_user::fourth_strided_iterator<BaseIter>;
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<FourthStridedIter> == base_passed_directly,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for custom user strided "
+                  "iterator with hidden friend ADL function without a body");
+}
+
+#endif // TEST_DPCPP_BACKEND_PRESENT
+
+int
+main()
+{
+
+#if TEST_DPCPP_BACKEND_PRESENT
+    // counting_iterator
+    test_with_base_iterator<true, oneapi::dpl::counting_iterator<std::int32_t>>();
+
+    // pointer (USM assumed)
+    test_with_base_iterator<true, int*>();
+
+    // create a usm allocated vector
+    sycl::queue q;
+    sycl::usm_allocator<int, sycl::usm::alloc::shared> alloc(q);
+    std::vector<int, sycl::usm_allocator<int, sycl::usm::alloc::shared>> vec(alloc);
+    test_with_base_iterator<TestUtils::__vector_impl_distinguishes_usm_allocator_from_default_v<decltype(vec.begin())>,
+                            decltype(vec.begin())>();
+
+    // custom iter type with legacy is_passed_directly trait defined
+    test_with_base_iterator<true, simple_passed_directly_iterator>();
+
+    // custom iter type with explicit is_passed_directly trait defined as false
+    test_with_base_iterator<false, simple_explicitly_not_passed_directly_iterator>();
+
+    // custom iter type implicitly not passed directly
+    test_with_base_iterator<false, simple_implicitly_not_passed_directly_iterator>();
+
+    // std vector with normal allocator
+    std::vector<int> vec2(10);
+    test_with_base_iterator<false, decltype(vec2.begin())>();
+
+    // test discard_iterator
+    static_assert(oneapi::dpl::is_passed_directly_to_device_v<oneapi::dpl::discard_iterator> == true,
+                  "is_passed_directly_in_onedpl_device_policies is not working correctly for discard iterator");
+
+#endif // TEST_DPCPP_BACKEND_PRESENT
+    return TestUtils::done(TEST_DPCPP_BACKEND_PRESENT);
+}