diff --git a/test/parallel_api/ranges/std_ranges_copy.pass.cpp b/test/parallel_api/ranges/std_ranges_copy.pass.cpp
index 368d528777c..b0177f409b5 100644
--- a/test/parallel_api/ranges/std_ranges_copy.pass.cpp
+++ b/test/parallel_api/ranges/std_ranges_copy.pass.cpp
@@ -35,7 +35,7 @@ main()
         return ret_type{std::ranges::begin(r_in) + size, std::ranges::begin(r_out) + size};
     };
 
-    test_range_algo<0, int, data_in_out>{}(dpl_ranges::copy,  copy_checker);
+    test_range_algo<0, int, data_in_out_lim>{}(dpl_ranges::copy,  copy_checker);
 
 #endif //_ENABLE_STD_RANGES_TESTING
 
diff --git a/test/parallel_api/ranges/std_ranges_test.h b/test/parallel_api/ranges/std_ranges_test.h
index b7a899110d6..773def66fcd 100644
--- a/test/parallel_api/ranges/std_ranges_test.h
+++ b/test/parallel_api/ranges/std_ranges_test.h
@@ -49,8 +49,10 @@ enum TestDataMode
 {
     data_in,
     data_in_out,
+    data_in_out_lim,
     data_in_in,
-    data_in_in_out
+    data_in_in_out,
+    data_in_in_out_lim
 };
 
 auto f_mutuable = [](auto&& val) { return val *= val; };
@@ -125,7 +127,7 @@ struct test
     process_data_in_out(int n_in, int n_out, Policy&& exec, Algo algo, Checker& checker, TransIn tr_in,
                         TransOut tr_out, auto... args)
     {
-        static_assert(mode == data_in_out);
+        static_assert(mode == data_in_out || mode == data_in_out_lim);
 
         constexpr int max_n = 10;
         DataType data_in[max_n] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
@@ -164,6 +166,14 @@ struct test
     template<typename Policy, typename Algo, typename Checker>
     std::enable_if_t<!std::is_same_v<Policy, std::true_type> && mode == data_in_out>
     operator()(Policy&& exec, Algo algo, Checker& checker, auto... args)
+    {
+        const int r_size = 10;
+        process_data_in_out(r_size, r_size, std::forward<Policy>(exec), algo, checker, args...);
+    }
+
+    template<typename Policy, typename Algo, typename Checker>
+    std::enable_if_t<!std::is_same_v<Policy, std::true_type> && mode == data_in_out_lim>
+    operator()(Policy&& exec, Algo algo, Checker& checker, auto... args)
     {
         const int r_size = 10;
         process_data_in_out(r_size, r_size, std::forward<Policy>(exec), algo, checker, args...);
@@ -206,7 +216,7 @@ struct test
     void
     process_data_in_in_out(int n_in1, int n_in2, int n_out, Policy&& exec, Algo algo, Checker& checker, TransIn tr_in, TransOut tr_out, auto... args)
     {
-        static_assert(mode == data_in_in_out);
+        static_assert(mode == data_in_in_out || mode == data_in_in_out_lim);
 
         constexpr int max_n = 10;
         DataType data_in1[max_n] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
@@ -247,6 +257,14 @@ struct test
     template<typename Policy, typename Algo, typename Checker>
     std::enable_if_t<!std::is_same_v<Policy, std::true_type> && mode == data_in_in_out>
     operator()(Policy&& exec, Algo algo, Checker& checker, auto... args)
+    {
+        const int r_size = 10;
+        process_data_in_in_out(r_size, r_size, r_size*2, std::forward<Policy>(exec), algo, checker, args...);
+    }
+
+    template<typename Policy, typename Algo, typename Checker>
+    std::enable_if_t<!std::is_same_v<Policy, std::true_type> && mode == data_in_in_out_lim>
+    operator()(Policy&& exec, Algo algo, Checker& checker, auto... args)
     {
         const int r_size = 10;
         process_data_in_in_out(r_size, r_size, r_size, std::forward<Policy>(exec), algo, checker, args...);
diff --git a/test/parallel_api/ranges/std_ranges_transform.pass.cpp b/test/parallel_api/ranges/std_ranges_transform.pass.cpp
index fa6a503e857..2afe0865c94 100644
--- a/test/parallel_api/ranges/std_ranges_transform.pass.cpp
+++ b/test/parallel_api/ranges/std_ranges_transform.pass.cpp
@@ -41,10 +41,10 @@ main()
         return ret_type{std::ranges::begin(r_in) + size, std::ranges::begin(r_out) +  size};
     };
 
-    test_range_algo<0, int, data_in_out>{}(dpl_ranges::transform, transform_unary_checker, f);
-    test_range_algo<1, int, data_in_out>{}(dpl_ranges::transform, transform_unary_checker, f, proj);
-    test_range_algo<2, P2, data_in_out>{}(dpl_ranges::transform, transform_unary_checker, f, &P2::x);
-    test_range_algo<3, P2, data_in_out>{}(dpl_ranges::transform, transform_unary_checker, f, &P2::proj);
+    test_range_algo<0, int, data_in_out_lim>{}(dpl_ranges::transform, transform_unary_checker, f);
+    test_range_algo<1, int, data_in_out_lim>{}(dpl_ranges::transform, transform_unary_checker, f, proj);
+    test_range_algo<2, P2, data_in_out_lim>{}(dpl_ranges::transform, transform_unary_checker, f, &P2::x);
+    test_range_algo<3, P2, data_in_out_lim>{}(dpl_ranges::transform, transform_unary_checker, f, &P2::proj);
 
     //A checker below modifies a return type; a range based version with policy has another return type.
     auto transform_binary_checker = [](std::ranges::random_access_range auto&& r_1,
@@ -68,10 +68,10 @@ main()
         return ret_type{std::ranges::begin(r_1) + size, std::ranges::begin(r_2) + size, std::ranges::begin(r_out) + size};
     };
 
-    test_range_algo<4, int, data_in_in_out>{}(dpl_ranges::transform, transform_binary_checker, binary_f);
-    test_range_algo<5, int, data_in_in_out>{}(dpl_ranges::transform, transform_binary_checker, binary_f, proj, proj);
-    test_range_algo<6, P2, data_in_in_out>{}(dpl_ranges::transform, transform_binary_checker, binary_f, &P2::x, &P2::x);
-    test_range_algo<7, P2, data_in_in_out>{}(dpl_ranges::transform, transform_binary_checker, binary_f, &P2::proj, &P2::proj);
+    test_range_algo<4, int, data_in_in_out_lim>{}(dpl_ranges::transform, transform_binary_checker, binary_f);
+    test_range_algo<5, int, data_in_in_out_lim>{}(dpl_ranges::transform, transform_binary_checker, binary_f, proj, proj);
+    test_range_algo<6, P2, data_in_in_out_lim>{}(dpl_ranges::transform, transform_binary_checker, binary_f, &P2::x, &P2::x);
+    test_range_algo<7, P2, data_in_in_out_lim>{}(dpl_ranges::transform, transform_binary_checker, binary_f, &P2::proj, &P2::proj);
 #endif //_ENABLE_STD_RANGES_TESTING
 
     return TestUtils::done(_ENABLE_STD_RANGES_TESTING);