From a9915ad89d9cd4efd808751c5b538be7fde370c8 Mon Sep 17 00:00:00 2001
From: aleks meshkov <alekseix.meshkov@intel.com>
Date: Fri, 2 Jun 2023 17:23:30 +0300
Subject: [PATCH 1/5] Cherry-picked PR #669 to avoid CI failures.

---
 tests/accessor/accessor_common.h              | 12 +++++
 .../accessor/accessor_default_values_core.cpp |  6 +--
 tests/accessor/accessor_exceptions_core.cpp   | 16 ++-----
 .../accessor_implicit_conversions_core.cpp    |  9 ++--
 tests/accessor/generic_accessor_api_core.cpp  |  3 +-
 ...cessor_common_buffer_constructors_core.cpp |  4 +-
 .../generic_accessor_def_constructor_core.cpp |  3 +-
 .../generic_accessor_linearization_core.cpp   |  3 +-
 ...or_placeholder_buffer_constructor_core.cpp |  4 +-
 ...der_buffer_constructor_exceptions_core.cpp |  5 +--
 ...ceholder_buffer_range_constructor_core.cpp |  4 +-
 ...ffer_range_constructor_exceptions_core.cpp |  5 +--
 ...r_buffer_range_offset_constructor_core.cpp |  5 +--
 ...nge_offset_constructor_exceptions_core.cpp |  6 +--
 ...er_zero_length_buffer_constructor_core.cpp |  4 +-
 ...o_length_buffer_range_constructor_core.cpp |  5 +--
 ...h_buffer_range_offset_constructor_core.cpp |  6 +--
 .../generic_accessor_properties_core.cpp      |  3 +-
 ...ric_accessor_zero_dim_constructor_core.cpp |  3 +-
 tests/accessor/host_accessor_api_core.cpp     |  3 +-
 .../host_accessor_constructors_core.cpp       |  3 +-
 .../host_accessor_linearization_core.cpp      |  3 +-
 .../host_accessor_properties_core.cpp         |  3 +-
 ..._accessor_access_among_work_items_core.cpp |  5 +--
 tests/accessor/local_accessor_api_core.cpp    |  3 +-
 .../local_accessor_constructors_core.cpp      |  3 +-
 .../local_accessor_linearization_core.cpp     |  3 +-
 tests/common/type_coverage.h                  | 44 +++++++++++++++++++
 28 files changed, 94 insertions(+), 82 deletions(-)

diff --git a/tests/accessor/accessor_common.h b/tests/accessor/accessor_common.h
index ff41b5e18..ad353b0b5 100644
--- a/tests/accessor/accessor_common.h
+++ b/tests/accessor/accessor_common.h
@@ -197,6 +197,18 @@ inline auto get_conformance_type_pack() {
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
 }
 
+template <template <typename, typename...> class action,
+          typename... actionArgsT>
+void common_run_tests() {
+  const auto types = get_conformance_type_pack();
+#if SYCL_CTS_ENABLE_FULL_CONFORMANCE
+  for_all_types_vectors_marray<action, actionArgsT...>(types);
+#else
+  for_all_types<action, actionArgsT...>(types);
+  for_type_vectors_marray_reduced<action, int, actionArgsT...>("int");
+#endif
+}
+
 /**
  * @brief Factory function for getting type_pack with access modes values
  */
diff --git a/tests/accessor/accessor_default_values_core.cpp b/tests/accessor/accessor_default_values_core.cpp
index 123e50cc5..6caed6d39 100644
--- a/tests/accessor/accessor_default_values_core.cpp
+++ b/tests/accessor/accessor_default_values_core.cpp
@@ -26,9 +26,7 @@ namespace accessor_default_values_test_core {
 using namespace sycl_cts;
 
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
-("Accessors constructor default values test core types.", "[accessor]")({
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_tests>(types);
-});
+("Accessors constructor default values test core types.",
+ "[accessor]")({ common_run_tests<run_tests>(); });
 
 }  // namespace accessor_default_values_test_core
diff --git a/tests/accessor/accessor_exceptions_core.cpp b/tests/accessor/accessor_exceptions_core.cpp
index 893b6f335..428302700 100644
--- a/tests/accessor/accessor_exceptions_core.cpp
+++ b/tests/accessor/accessor_exceptions_core.cpp
@@ -28,22 +28,14 @@ using namespace sycl_cts;
 
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp, DPCPP)
 ("Generic sycl::accessor constructor exceptions test. Core types.",
- "[accessor]")({
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_tests_with_types, generic_accessor>(types);
-});
+ "[accessor]")({ common_run_tests<run_tests, generic_accessor>(); });
 
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp, DPCPP)
 ("sycl::local_accessor constructor exceptions test. Core types.",
- "[accessor]")({
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_tests_with_types, local_accessor>(types);
-});
+ "[accessor]")({ common_run_tests<run_tests, local_accessor>(); });
 
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp, DPCPP)
-("sycl::host_accessor constructor exceptions test. Core types.", "[accessor]")({
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_tests_with_types, host_accessor>(types);
-});
+("sycl::host_accessor constructor exceptions test. Core types.",
+ "[accessor]")({ common_run_tests<run_tests, host_accessor>(); });
 
 }  // namespace accessor_exceptions_test_core
diff --git a/tests/accessor/accessor_implicit_conversions_core.cpp b/tests/accessor/accessor_implicit_conversions_core.cpp
index d9e5ed677..940379878 100644
--- a/tests/accessor/accessor_implicit_conversions_core.cpp
+++ b/tests/accessor/accessor_implicit_conversions_core.cpp
@@ -28,22 +28,19 @@ namespace accessor_implicit_conversions_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("Generic sycl::accessor implicit conversion. core types",
  "[accessor][generic_accessor][conversion][core]")({
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_test_generic>(types);
+  common_run_tests<run_test_generic>();
 });
 
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("The sycl::local_accessor implicit conversion. core types",
  "[accessor][local_accessor][conversion][core]")({
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_test_local>(types);
+  common_run_tests<run_test_local>();
 });
 
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("The sycl::host_accessor implicit conversion. core types",
  "[accessor][host_accessor][conversion][core]")({
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_test_host>(types);
+  common_run_tests<run_test_host>();
 });
 
 }  // namespace accessor_implicit_conversions_core
diff --git a/tests/accessor/generic_accessor_api_core.cpp b/tests/accessor/generic_accessor_api_core.cpp
index 25ea1f239..450cde07e 100644
--- a/tests/accessor/generic_accessor_api_core.cpp
+++ b/tests/accessor/generic_accessor_api_core.cpp
@@ -24,8 +24,7 @@ namespace generic_accessor_api_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp, DPCPP)
 ("Generic sycl::accessor api. core types", "[accessor]")({
   using namespace generic_accessor_api_common;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_generic_api_for_type>(types);
+  common_run_tests<run_generic_api_for_type>();
 });
 
 }  // namespace generic_accessor_api_core
diff --git a/tests/accessor/generic_accessor_common_buffer_constructors_core.cpp b/tests/accessor/generic_accessor_common_buffer_constructors_core.cpp
index 721d846d1..fe4c03bd4 100644
--- a/tests/accessor/generic_accessor_common_buffer_constructors_core.cpp
+++ b/tests/accessor/generic_accessor_common_buffer_constructors_core.cpp
@@ -38,9 +38,7 @@ namespace generic_accessor_common_buffer_constructors_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp, DPCPP)
 ("Generic sycl::accessor buffer constructors. core types", "[accessor]")({
   using namespace generic_accessor_common_buffer_constructors;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_generic_common_buffer_constructors_test>(
-      types);
+  common_run_tests<run_generic_common_buffer_constructors_test>();
 });
 
 }  // namespace generic_accessor_common_buffer_constructors_core
diff --git a/tests/accessor/generic_accessor_def_constructor_core.cpp b/tests/accessor/generic_accessor_def_constructor_core.cpp
index 216f3b0b6..1ef648016 100644
--- a/tests/accessor/generic_accessor_def_constructor_core.cpp
+++ b/tests/accessor/generic_accessor_def_constructor_core.cpp
@@ -35,8 +35,7 @@ namespace generic_accessor_def_constructor_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("Generic sycl::accessor def constructors. core types", "[accessor]")({
   using namespace generic_accessor_def_constructor;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_generic_def_constructor_test>(types);
+  common_run_tests<run_generic_def_constructor_test>();
 });
 
 }  // namespace generic_accessor_def_constructor_core
diff --git a/tests/accessor/generic_accessor_linearization_core.cpp b/tests/accessor/generic_accessor_linearization_core.cpp
index 68cacb243..1e49304d5 100644
--- a/tests/accessor/generic_accessor_linearization_core.cpp
+++ b/tests/accessor/generic_accessor_linearization_core.cpp
@@ -37,8 +37,7 @@ namespace generic_accessor_linearization_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("Generic sycl::accessor linearization test. core types", "[accessor]")({
   using namespace generic_accessor_linearization;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_generic_linearization_for_type>(types);
+  common_run_tests<run_generic_linearization_for_type>();
 });
 
 }  // namespace generic_accessor_linearization_core
diff --git a/tests/accessor/generic_accessor_placeholder_buffer_constructor_core.cpp b/tests/accessor/generic_accessor_placeholder_buffer_constructor_core.cpp
index 09b84d139..1828b5d34 100644
--- a/tests/accessor/generic_accessor_placeholder_buffer_constructor_core.cpp
+++ b/tests/accessor/generic_accessor_placeholder_buffer_constructor_core.cpp
@@ -37,9 +37,7 @@ namespace generic_accessor_placeholder_buffer_constructor_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("Generic sycl::accessor placeholder constructors. core types", "[accessor]")({
   using namespace generic_accessor_placeholder_buffer_constructor;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_generic_placeholder_buffer_constructor_test>(
-      types);
+  common_run_tests<run_generic_placeholder_buffer_constructor_test>();
 });
 
 }  // namespace generic_accessor_placeholder_buffer_constructor_core
diff --git a/tests/accessor/generic_accessor_placeholder_buffer_constructor_exceptions_core.cpp b/tests/accessor/generic_accessor_placeholder_buffer_constructor_exceptions_core.cpp
index 06b7580a7..06a45b29a 100644
--- a/tests/accessor/generic_accessor_placeholder_buffer_constructor_exceptions_core.cpp
+++ b/tests/accessor/generic_accessor_placeholder_buffer_constructor_exceptions_core.cpp
@@ -38,9 +38,8 @@ DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("Generic sycl::accessor placeholder buffer constructor exceptions. core types",
  "[accessor]")({
   using namespace generic_accessor_placeholder_buffer_constructor_exceptions;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<
-      run_generic_placeholder_buffer_constructor_exceptions_test>(types);
+  common_run_tests<
+      run_generic_placeholder_buffer_constructor_exceptions_test>();
 });
 
 }  // namespace generic_accessor_placeholder_buffer_constructor_exceptions_core
diff --git a/tests/accessor/generic_accessor_placeholder_buffer_range_constructor_core.cpp b/tests/accessor/generic_accessor_placeholder_buffer_range_constructor_core.cpp
index 8c8c56998..2adea5d25 100644
--- a/tests/accessor/generic_accessor_placeholder_buffer_range_constructor_core.cpp
+++ b/tests/accessor/generic_accessor_placeholder_buffer_range_constructor_core.cpp
@@ -38,9 +38,7 @@ DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("Generic sycl::accessor placeholder buffer range constructor. core types",
  "[accessor]")({
   using namespace generic_accessor_placeholder_buffer_range_constructor;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<
-      run_generic_placeholder_buffer_range_constructor_test>(types);
+  common_run_tests<run_generic_placeholder_buffer_range_constructor_test>();
 });
 
 }  // namespace generic_accessor_placeholder_buffer_range_constructor_core
diff --git a/tests/accessor/generic_accessor_placeholder_buffer_range_constructor_exceptions_core.cpp b/tests/accessor/generic_accessor_placeholder_buffer_range_constructor_exceptions_core.cpp
index a6a84aaf4..eaf5770ec 100644
--- a/tests/accessor/generic_accessor_placeholder_buffer_range_constructor_exceptions_core.cpp
+++ b/tests/accessor/generic_accessor_placeholder_buffer_range_constructor_exceptions_core.cpp
@@ -39,9 +39,8 @@ DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
  "types",
  "[accessor]")({
   using namespace generic_accessor_placeholder_buffer_range_constructor_exceptions;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<
-      run_generic_placeholder_buffer_range_constructor_exceptions_test>(types);
+  common_run_tests<
+      run_generic_placeholder_buffer_range_constructor_exceptions_test>();
 });
 
 }  // namespace
diff --git a/tests/accessor/generic_accessor_placeholder_buffer_range_offset_constructor_core.cpp b/tests/accessor/generic_accessor_placeholder_buffer_range_offset_constructor_core.cpp
index d979791b6..24f0a7b1d 100644
--- a/tests/accessor/generic_accessor_placeholder_buffer_range_offset_constructor_core.cpp
+++ b/tests/accessor/generic_accessor_placeholder_buffer_range_offset_constructor_core.cpp
@@ -39,9 +39,8 @@ DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
  "types",
  "[accessor]")({
   using namespace generic_accessor_placeholder_buffer_range_offset_constructor;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<
-      run_generic_placeholder_buffer_range_offset_constructor_test>(types);
+  common_run_tests<
+      run_generic_placeholder_buffer_range_offset_constructor_test>();
 });
 
 }  // namespace
diff --git a/tests/accessor/generic_accessor_placeholder_buffer_range_offset_constructor_exceptions_core.cpp b/tests/accessor/generic_accessor_placeholder_buffer_range_offset_constructor_exceptions_core.cpp
index 3da114356..e30c1745d 100644
--- a/tests/accessor/generic_accessor_placeholder_buffer_range_offset_constructor_exceptions_core.cpp
+++ b/tests/accessor/generic_accessor_placeholder_buffer_range_offset_constructor_exceptions_core.cpp
@@ -39,10 +39,8 @@ DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
  "exceptions. core types",
  "[accessor]")({
   using namespace generic_accessor_placeholder_buffer_range_offset_constructor_exceptions;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<
-      run_generic_placeholder_buffer_range_offset_constructor_exceptions_test>(
-      types);
+  common_run_tests<
+      run_generic_placeholder_buffer_range_offset_constructor_exceptions_test>();
 });
 
 }  // namespace
diff --git a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_constructor_core.cpp b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_constructor_core.cpp
index 74f584119..657fd38c2 100644
--- a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_constructor_core.cpp
+++ b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_constructor_core.cpp
@@ -39,9 +39,7 @@ DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
  "types",
  "[accessor]")({
   using namespace generic_accessor_placeholder_zero_length_buffer_constructor;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<
-      run_generic_placeholder_zero_length_buffer_constructor>(types);
+  common_run_tests<run_generic_placeholder_zero_length_buffer_constructor>();
 });
 
 }  // namespace generic_accessor_placeholder_zero_length_buffer_constructor_core
diff --git a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_constructor_core.cpp b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_constructor_core.cpp
index 5ed777663..b94e23fcc 100644
--- a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_constructor_core.cpp
+++ b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_constructor_core.cpp
@@ -39,9 +39,8 @@ DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
  "core types",
  "[accessor]")({
   using namespace generic_accessor_placeholder_zero_length_buffer_range_constructor;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<
-      run_generic_placeholder_zero_length_buffer_range_constructor_test>(types);
+  common_run_tests<
+      run_generic_placeholder_zero_length_buffer_range_constructor_test>();
 });
 
 }  // namespace
diff --git a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor_core.cpp b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor_core.cpp
index 8a2adece5..6fe4e63c6 100644
--- a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor_core.cpp
+++ b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor_core.cpp
@@ -39,10 +39,8 @@ DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
  "constructor. core types",
  "[accessor]")({
   using namespace generic_accessor_placeholder_zero_length_buffer_range_offset_constructor;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<
-      run_generic_placeholder_zero_length_buffer_range_offset_constructor_test>(
-      types);
+  common_run_tests<
+      run_generic_placeholder_zero_length_buffer_range_offset_constructor_test>();
 });
 
 }  // namespace
diff --git a/tests/accessor/generic_accessor_properties_core.cpp b/tests/accessor/generic_accessor_properties_core.cpp
index 54c7a1fe5..068d8a60b 100644
--- a/tests/accessor/generic_accessor_properties_core.cpp
+++ b/tests/accessor/generic_accessor_properties_core.cpp
@@ -23,8 +23,7 @@ namespace generic_accessor_properties_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("Generic sycl::accessor properties test. core types", "[accessor]")({
   using namespace generic_accessor_properties;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_generic_properties_tests>(types);
+  common_run_tests<run_generic_properties_tests>();
 });
 
 }  // namespace generic_accessor_properties_core
diff --git a/tests/accessor/generic_accessor_zero_dim_constructor_core.cpp b/tests/accessor/generic_accessor_zero_dim_constructor_core.cpp
index df253e78c..83bad9ab0 100644
--- a/tests/accessor/generic_accessor_zero_dim_constructor_core.cpp
+++ b/tests/accessor/generic_accessor_zero_dim_constructor_core.cpp
@@ -37,8 +37,7 @@ namespace generic_accessor_zero_dim_constructor_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("Generic sycl::accessor zero-dim constructors. core types", "[accessor]")({
   using namespace generic_accessor_zero_dim_constructor;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_generic_zero_dim_constructor_test>(types);
+  common_run_tests<run_generic_zero_dim_constructor_test>();
 });
 
 }  // namespace generic_accessor_zero_dim_constructor_core
diff --git a/tests/accessor/host_accessor_api_core.cpp b/tests/accessor/host_accessor_api_core.cpp
index a7b6065a7..3d9f484ea 100644
--- a/tests/accessor/host_accessor_api_core.cpp
+++ b/tests/accessor/host_accessor_api_core.cpp
@@ -21,8 +21,7 @@ namespace host_accessor_api_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp, DPCPP)
 ("sycl::host_accessor api. core types", "[accessor]")({
   using namespace host_accessor_api_common;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_host_accessor_api_for_type>(types);
+  common_run_tests<run_host_accessor_api_for_type>();
 });
 
 }  // namespace host_accessor_api_core
diff --git a/tests/accessor/host_accessor_constructors_core.cpp b/tests/accessor/host_accessor_constructors_core.cpp
index 95fbb02f2..b0c1b5c60 100644
--- a/tests/accessor/host_accessor_constructors_core.cpp
+++ b/tests/accessor/host_accessor_constructors_core.cpp
@@ -35,8 +35,7 @@ namespace host_accessor_constructors_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("sycl::host_accessor constructors. core types", "[accessor]")({
   using namespace host_accessor_constructors;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_host_constructors_test>(types);
+  common_run_tests<run_host_constructors_test>();
 });
 
 }  // namespace host_accessor_constructors_core
diff --git a/tests/accessor/host_accessor_linearization_core.cpp b/tests/accessor/host_accessor_linearization_core.cpp
index 2434918c8..c28645250 100644
--- a/tests/accessor/host_accessor_linearization_core.cpp
+++ b/tests/accessor/host_accessor_linearization_core.cpp
@@ -34,8 +34,7 @@ namespace host_accessor_liniarization_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("sycl::host_accessor linearization. core types", "[accessor]")({
   using namespace host_accessor_linearization;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_host_linearization_for_type>(types);
+  common_run_tests<run_host_linearization_for_type>();
 });
 
 }  // namespace host_accessor_liniarization_core
diff --git a/tests/accessor/host_accessor_properties_core.cpp b/tests/accessor/host_accessor_properties_core.cpp
index f81c9ee86..b240d6f36 100644
--- a/tests/accessor/host_accessor_properties_core.cpp
+++ b/tests/accessor/host_accessor_properties_core.cpp
@@ -22,8 +22,7 @@ namespace host_accessor_properties_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("sycl::host_accessor properties. core types", "[accessor]")({
   using namespace host_accessor_properties;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_host_properties_tests>(types);
+  common_run_tests<run_host_properties_tests>();
 });
 
 }  // namespace host_accessor_properties_core
diff --git a/tests/accessor/local_accessor_access_among_work_items_core.cpp b/tests/accessor/local_accessor_access_among_work_items_core.cpp
index 2381c183f..b44769544 100644
--- a/tests/accessor/local_accessor_access_among_work_items_core.cpp
+++ b/tests/accessor/local_accessor_access_among_work_items_core.cpp
@@ -25,10 +25,7 @@ namespace local_accessor_access_among_work_items_core {
 
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("sycl::local_accessor access among work items. core types", "[accessor]")({
-  const auto types = get_conformance_type_pack();
-
-  for_all_types_vectors_marray<
-      run_local_accessor_access_among_work_items_tests>(types);
+  common_run_tests<run_local_accessor_access_among_work_items_tests>();
 });
 
 }  // namespace local_accessor_access_among_work_items_core
diff --git a/tests/accessor/local_accessor_api_core.cpp b/tests/accessor/local_accessor_api_core.cpp
index 9c888b280..462fbbd10 100644
--- a/tests/accessor/local_accessor_api_core.cpp
+++ b/tests/accessor/local_accessor_api_core.cpp
@@ -21,8 +21,7 @@ namespace local_accessor_api_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp, DPCPP)
 ("sycl::local_accessor api. core types", "[accessor]")({
   using namespace local_accessor_api_common;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_local_api_for_type>(types);
+  common_run_tests<run_local_api_for_type>();
 });
 
 }  // namespace local_accessor_api_core
diff --git a/tests/accessor/local_accessor_constructors_core.cpp b/tests/accessor/local_accessor_constructors_core.cpp
index f13e22c8a..8330bc74a 100644
--- a/tests/accessor/local_accessor_constructors_core.cpp
+++ b/tests/accessor/local_accessor_constructors_core.cpp
@@ -24,7 +24,6 @@ namespace local_accessor_constructors_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp, DPCPP)
 ("sycl::local_accessor constructors. core types", "[accessor]")({
   using namespace local_accessor_constructors;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_local_constructors_test>(types);
+  common_run_tests<run_local_constructors_test>();
 });
 }  // namespace local_accessor_constructors_core
diff --git a/tests/accessor/local_accessor_linearization_core.cpp b/tests/accessor/local_accessor_linearization_core.cpp
index f751a81ab..72e88f841 100644
--- a/tests/accessor/local_accessor_linearization_core.cpp
+++ b/tests/accessor/local_accessor_linearization_core.cpp
@@ -34,8 +34,7 @@ namespace local_accessor_liniarization_core {
 DISABLED_FOR_TEST_CASE(hipSYCL, ComputeCpp)
 ("sycl::local_accessor linearization. core types", "[accessor]")({
   using namespace local_accessor_linearization;
-  const auto types = get_conformance_type_pack();
-  for_all_types_vectors_marray<run_local_linearization_for_type>(types);
+  common_run_tests<run_local_linearization_for_type>();
 });
 
 }  // namespace local_accessor_liniarization_core
diff --git a/tests/common/type_coverage.h b/tests/common/type_coverage.h
index 444125b19..8cf7d2fd8 100644
--- a/tests/common/type_coverage.h
+++ b/tests/common/type_coverage.h
@@ -496,6 +496,50 @@ void for_type_vectors_marray(argsT &&...args) {
         std::forward<argsT>(args)...);
   }
 }
+
+/**
+ * @brief Run action for type, reduced number of vectors and marrays of this
+ * type
+ * @tparam action Functor template for action to run
+ * @tparam T Type to instantiate functor template with
+ * @tparam actionArgsT Parameter pack to use for functor template instantiation
+ * @tparam argsT Deduced parameter pack for arguments to forward into the call
+ * @param args Arguments to forward into the call
+ */
+template <template <typename, typename...> class action, typename T,
+          typename... actionArgsT, typename... argsT>
+void for_type_vectors_marray_reduced(argsT&&... args) {
+  constexpr std::size_t small_marray_size = 2;
+  constexpr std::size_t medium_marray_size = 5;
+  constexpr std::size_t large_marray_size = 10;
+  if constexpr (std::is_same<T, bool>::value) {
+    for_all_types<action, actionArgsT...>(
+        type_pack<T, typename sycl::template marray<T, small_marray_size>,
+                  typename sycl::template marray<T, medium_marray_size>,
+                  typename sycl::template marray<T, large_marray_size>>{},
+        std::forward<argsT>(args)...);
+  } else {
+    for_all_types<action, actionArgsT...>(
+        // Provides all possible sizes (according to SYCL-2020 rev.5) for
+        // sycl::vec
+        type_pack<T,
+#if SYCL_CTS_ENABLE_FULL_CONFORMANCE
+                  typename sycl::template vec<T, 1>,
+                  typename sycl::template vec<T, 2>,
+#endif
+                  typename sycl::template vec<T, 3>,
+                  typename sycl::template vec<T, 4>,
+#if SYCL_CTS_ENABLE_FULL_CONFORMANCE
+                  typename sycl::template vec<T, 8>,
+                  typename sycl::template vec<T, 16>,
+                  // Provide different sizes for sycl::marray
+                  typename sycl::template marray<T, small_marray_size>,
+                  typename sycl::template marray<T, medium_marray_size>,
+#endif
+                  typename sycl::template marray<T, large_marray_size>>{},
+        std::forward<argsT>(args)...);
+  }
+}
 #endif  // !SYCL_CTS_COMPILING_WITH_HIPSYCL
 
 // FIXME: re-enable when marrray is implemented in hipsycl

From c081921777eb7915d5a30f078ccfdfcfb780e659 Mon Sep 17 00:00:00 2001
From: aleks meshkov <alekseix.meshkov@intel.com>
Date: Fri, 2 Jun 2023 17:54:06 +0300
Subject: [PATCH 2/5] Fix placeholder accessor wrong checking

Moved placeholder accessor constructor checking from sycl::handler command.
---
 tests/accessor/accessor_common.h              | 98 ++++++++++++-------
 ...aceholder_zero_length_buffer_constructor.h |  8 +-
 ...der_zero_length_buffer_range_constructor.h |  8 +-
 ...o_length_buffer_range_offset_constructor.h | 10 +-
 4 files changed, 76 insertions(+), 48 deletions(-)

diff --git a/tests/accessor/accessor_common.h b/tests/accessor/accessor_common.h
index ad353b0b5..3bcbef10e 100644
--- a/tests/accessor/accessor_common.h
+++ b/tests/accessor/accessor_common.h
@@ -335,8 +335,8 @@ struct tag_factory<accessor_type::host_accessor> {
  * @param res_acc Instance of result accessor
  */
 template <typename TestingAccT, typename ResultAccT>
-void check_empty_accessor_constructor_post_conditions(TestingAccT testing_acc,
-                                                      ResultAccT res_acc) {
+void check_empty_accessor_constructor_post_conditions(
+    TestingAccT testing_acc, ResultAccT res_acc, bool check_iterator_methods) {
   size_t res_i = 0;
   // (empty() == true)
   res_acc[res_i++] = testing_acc.empty() == true;
@@ -346,11 +346,13 @@ void check_empty_accessor_constructor_post_conditions(TestingAccT testing_acc,
   res_acc[res_i++] = testing_acc.size() == 0;
   res_acc[res_i++] = testing_acc.max_size() == 0;
 
-  // The only iterator that can be obtained is nullptr
-  res_acc[res_i++] = testing_acc.begin() == testing_acc.end();
-  res_acc[res_i++] = testing_acc.cbegin() == testing_acc.cend();
-  res_acc[res_i++] = testing_acc.rbegin() == testing_acc.rend();
-  res_acc[res_i++] = testing_acc.crbegin() == testing_acc.crend();
+  if (check_iterator_methods) {
+    // The only iterator that can be obtained is nullptr
+    res_acc[res_i++] = testing_acc.begin() == testing_acc.end();
+    res_acc[res_i++] = testing_acc.cbegin() == testing_acc.cend();
+    res_acc[res_i++] = testing_acc.rbegin() == testing_acc.rend();
+    res_acc[res_i++] = testing_acc.crbegin() == testing_acc.crend();
+  }
 }
 // FIXME: re-enable when handler.host_task and sycl::errc is implemented in
 // hipsycl and computcpp
@@ -374,32 +376,54 @@ void check_def_constructor(GetAccFunctorT get_accessor_functor) {
   auto queue = once_per_unit::get_queue();
   sycl::range<1> r(1);
   const size_t conditions_checks_size = 8;
-  bool conditions_check[conditions_checks_size]{false};
+  bool conditions_check[conditions_checks_size];
+  std::fill(conditions_check, conditions_check + conditions_checks_size, true);
 
+  auto acc = get_accessor_functor();
   if constexpr (AccType != accessor_type::host_accessor) {
-    sycl::buffer res_buf(conditions_check, sycl::range(conditions_checks_size));
+    check_empty_accessor_constructor_post_conditions(acc, conditions_check,
+                                                     false);
+  } else {
+    check_empty_accessor_constructor_post_conditions(acc, conditions_check,
+                                                     true);
+  }
 
-    queue
-        .submit([&](sycl::handler& cgh) {
-          sycl::accessor res_acc(res_buf, cgh);
-          auto acc = get_accessor_functor();
-          if (acc.is_placeholder()) {
-            cgh.require(acc);
-          }
-          if constexpr (Target == sycl::target::host_task) {
-            cgh.host_task([=] {
-              check_empty_accessor_constructor_post_conditions(acc, res_acc);
-            });
-          } else if constexpr (Target == sycl::target::device) {
-            cgh.parallel_for_work_group(r, [=](sycl::group<1>) {
-              check_empty_accessor_constructor_post_conditions(acc, res_acc);
-            });
-          }
-        })
-        .wait_and_throw();
+  for (size_t i = 0; i < conditions_checks_size; i++) {
+    CHECK(conditions_check[i]);
+  }
+}
+
+/**
+ * @brief Common function that constructs placeholder accessor with zero-length
+ * buffer and checks post-conditions
+ *
+ * @tparam AccType Type of the accessor
+ * @tparam DataT Type of underlying data
+ * @tparam Dimension Dimensions of the accessor
+ * @tparam AccessMode Access mode of the accessor
+ * @tparam Target Target of accessor
+ * @tparam GetAccFunctorT Type of functor for accessor creation
+ */
+template <accessor_type AccType, typename DataT, int Dimension,
+          sycl::access_mode AccessMode = sycl::access_mode::read_write,
+          sycl::target Target = sycl::target::device, typename GetAccFunctorT>
+void check_zero_length_buffer_placeholder_constructor(
+    GetAccFunctorT get_accessor_functor) {
+  auto queue = once_per_unit::get_queue();
+  sycl::range<Dimension> r =
+      util::get_cts_object::range<Dimension>::get(0, 0, 0);
+  sycl::buffer<DataT, Dimension> data_buf(r);
+  const size_t conditions_checks_size = 8;
+  bool conditions_check[conditions_checks_size];
+  std::fill(conditions_check, conditions_check + conditions_checks_size, true);
+
+  auto acc = get_accessor_functor(data_buf);
+  if constexpr (AccType != accessor_type::host_accessor) {
+    check_empty_accessor_constructor_post_conditions(acc, conditions_check,
+                                                     false);
   } else {
-    auto acc = get_accessor_functor();
-    check_empty_accessor_constructor_post_conditions(acc, conditions_check);
+    check_empty_accessor_constructor_post_conditions(acc, conditions_check,
+                                                     true);
   }
 
   for (size_t i = 0; i < conditions_checks_size; i++) {
@@ -427,29 +451,33 @@ void check_zero_length_buffer_constructor(GetAccFunctorT get_accessor_functor) {
       util::get_cts_object::range<Dimension>::get(0, 0, 0);
   sycl::buffer<DataT, Dimension> data_buf(r);
   const size_t conditions_checks_size = 8;
-  bool conditions_check[conditions_checks_size]{false};
+  bool conditions_check[conditions_checks_size];
+  std::fill(conditions_check, conditions_check + conditions_checks_size, true);
 
   if constexpr (AccType != accessor_type::host_accessor) {
     sycl::buffer res_buf(conditions_check, sycl::range(conditions_checks_size));
 
     queue
         .submit([&](sycl::handler& cgh) {
-          sycl::accessor res_acc(res_buf);
+          sycl::accessor res_acc(res_buf, cgh);
           auto acc = get_accessor_functor(data_buf, cgh);
           if constexpr (Target == sycl::target::host_task) {
             cgh.host_task([=] {
-              check_empty_accessor_constructor_post_conditions(acc, res_acc);
+              check_empty_accessor_constructor_post_conditions(acc, res_acc,
+                                                               false);
             });
           } else if constexpr (Target == sycl::target::device) {
             cgh.parallel_for_work_group(r, [=](sycl::group<Dimension>) {
-              check_empty_accessor_constructor_post_conditions(acc, res_acc);
+              check_empty_accessor_constructor_post_conditions(acc, res_acc,
+                                                               false);
             });
           }
         })
         .wait_and_throw();
   } else {
     auto acc = get_accessor_functor(data_buf);
-    check_empty_accessor_constructor_post_conditions(acc, conditions_check);
+    check_empty_accessor_constructor_post_conditions(acc, conditions_check,
+                                                     true);
   }
 
   for (size_t i = 0; i < conditions_checks_size; i++) {
@@ -655,7 +683,7 @@ void check_common_constructor(const sycl::range<Dimension>& r,
 
     queue
         .submit([&](sycl::handler& cgh) {
-          sycl::accessor res_acc(res_buf);
+          sycl::accessor res_acc(res_buf, cgh);
           auto acc = get_accessor_functor(data_buf, cgh);
 
           if constexpr (AccType == accessor_type::generic_accessor) {
diff --git a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_constructor.h b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_constructor.h
index 54aa332c5..ad44be1ab 100644
--- a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_constructor.h
+++ b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_constructor.h
@@ -46,12 +46,12 @@ void test_placeholder_zero_length_buffer_constructor(
       "From zero-length buffer placeholder constructor");
 
   SECTION(section_name) {
-    auto get_acc_functor = [](sycl::buffer<DataT, Dimension>& data_buf,
-                              sycl::handler& cgh) {
+    auto get_acc_functor = [](sycl::buffer<DataT, Dimension>& data_buf) {
       return sycl::accessor<DataT, Dimension, AccessMode, Target>(data_buf);
     };
-    check_zero_length_buffer_constructor<AccType, DataT, Dimension, AccessMode,
-                                         Target>(get_acc_functor);
+    check_zero_length_buffer_placeholder_constructor<AccType, DataT, Dimension,
+                                                     AccessMode, Target>(
+        get_acc_functor);
   }
 }
 
diff --git a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_constructor.h b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_constructor.h
index 9a9803f3c..796950076 100644
--- a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_constructor.h
+++ b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_constructor.h
@@ -46,13 +46,13 @@ void test_placeholder_zero_length_buffer_range_constructor(
       "From zero-length buffer and range placeholder constructor");
 
   SECTION(section_name) {
-    auto get_acc_functor = [r_zero](sycl::buffer<DataT, Dimension>& data_buf,
-                                    sycl::handler& cgh) {
+    auto get_acc_functor = [r_zero](sycl::buffer<DataT, Dimension>& data_buf) {
       return sycl::accessor<DataT, Dimension, AccessMode, Target>(data_buf,
                                                                   r_zero);
     };
-    check_zero_length_buffer_constructor<AccType, DataT, Dimension, AccessMode,
-                                         Target>(get_acc_functor);
+    check_zero_length_buffer_placeholder_constructor<AccType, DataT, Dimension,
+                                                     AccessMode, Target>(
+        get_acc_functor);
   }
 }
 
diff --git a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor.h b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor.h
index 5fc6a667e..ece1fc259 100644
--- a/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor.h
+++ b/tests/accessor/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor.h
@@ -46,14 +46,14 @@ void test_placeholder_zero_length_buffser_range_offset_constructor(
       "From zero-length buffer, range and offset placeholder constructor");
 
   SECTION(section_name) {
-    auto get_acc_functor = [r_zero, offset](
-                               sycl::buffer<DataT, Dimension>& data_buf,
-                               sycl::handler& cgh) {
+    auto get_acc_functor = [r_zero,
+                            offset](sycl::buffer<DataT, Dimension>& data_buf) {
       return sycl::accessor<DataT, Dimension, AccessMode, Target>(
           data_buf, r_zero, offset);
     };
-    check_zero_length_buffer_constructor<AccType, DataT, Dimension, AccessMode,
-                                         Target>(get_acc_functor);
+    check_zero_length_buffer_placeholder_constructor<AccType, DataT, Dimension,
+                                                     AccessMode, Target>(
+        get_acc_functor);
   }
 }
 

From 9e45d6556673f6f60b170bdf51d155b625e90e63 Mon Sep 17 00:00:00 2001
From: aleks meshkov <alekseix.meshkov@intel.com>
Date: Mon, 26 Jun 2023 12:12:15 +0300
Subject: [PATCH 3/5] Apply comments

---
 tests/accessor/accessor_common.h | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/tests/accessor/accessor_common.h b/tests/accessor/accessor_common.h
index 25708f41e..636031149 100644
--- a/tests/accessor/accessor_common.h
+++ b/tests/accessor/accessor_common.h
@@ -339,6 +339,8 @@ struct tag_factory<accessor_type::host_accessor> {
  * @param testing_acc Instance of TestingAccT that were constructed with default
  * constructor
  * @param res_acc Instance of result accessor
+ * @param check_iterator_methods Flag to avoid undefined behavior on access to
+ * uninitialized underlying buffer
  */
 template <typename TestingAccT, typename ResultAccT>
 void check_empty_accessor_constructor_post_conditions(
@@ -387,11 +389,15 @@ void check_def_constructor(GetAccFunctorT get_accessor_functor) {
 
   auto acc = get_accessor_functor();
   if constexpr (AccType != accessor_type::host_accessor) {
+    // Disable checking iteration methods with empty device accessor
+    // to avoid undefined behavior
+    bool check_iterator_methods = false;
     check_empty_accessor_constructor_post_conditions(acc, conditions_check,
-                                                     false);
+                                                     check_iterator_methods);
   } else {
+    bool check_iterator_methods = true;
     check_empty_accessor_constructor_post_conditions(acc, conditions_check,
-                                                     true);
+                                                     check_iterator_methods);
   }
 
   for (size_t i = 0; i < conditions_checks_size; i++) {
@@ -425,11 +431,15 @@ void check_zero_length_buffer_placeholder_constructor(
 
   auto acc = get_accessor_functor(data_buf);
   if constexpr (AccType != accessor_type::host_accessor) {
+    // Disable checking iteration methods with empty device accessor
+    // to avoid undefined behavior
+    bool check_iterator_methods = false;
     check_empty_accessor_constructor_post_conditions(acc, conditions_check,
-                                                     false);
+                                                     check_iterator_methods);
   } else {
+    bool check_iterator_methods = true;
     check_empty_accessor_constructor_post_conditions(acc, conditions_check,
-                                                     true);
+                                                     check_iterator_methods);
   }
 
   for (size_t i = 0; i < conditions_checks_size; i++) {
@@ -467,23 +477,27 @@ void check_zero_length_buffer_constructor(GetAccFunctorT get_accessor_functor) {
         .submit([&](sycl::handler& cgh) {
           sycl::accessor res_acc(res_buf, cgh);
           auto acc = get_accessor_functor(data_buf, cgh);
+          // Disable checking iteration methods with empty device accessor
+          // to avoid undefined behavior
+          bool check_iterator_methods = false;
           if constexpr (Target == sycl::target::host_task) {
             cgh.host_task([=] {
               check_empty_accessor_constructor_post_conditions(acc, res_acc,
-                                                               false);
+                                                               check_iterator_methods);
             });
           } else if constexpr (Target == sycl::target::device) {
             cgh.parallel_for_work_group(r, [=](sycl::group<Dimension>) {
               check_empty_accessor_constructor_post_conditions(acc, res_acc,
-                                                               false);
+                                                               check_iterator_methods);
             });
           }
         })
         .wait_and_throw();
   } else {
     auto acc = get_accessor_functor(data_buf);
+    bool check_iterator_methods = true;
     check_empty_accessor_constructor_post_conditions(acc, conditions_check,
-                                                     true);
+                                                     check_iterator_methods);
   }
 
   for (size_t i = 0; i < conditions_checks_size; i++) {

From ccfcfaec3ea63f936b57b97f1f9fd12dfb076ef4 Mon Sep 17 00:00:00 2001
From: aleks meshkov <alekseix.meshkov@intel.com>
Date: Tue, 27 Jun 2023 09:44:29 +0300
Subject: [PATCH 4/5] Fix CI

---
 tests/accessor/accessor_common.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/accessor/accessor_common.h b/tests/accessor/accessor_common.h
index 82c97f46a..221072cfc 100644
--- a/tests/accessor/accessor_common.h
+++ b/tests/accessor/accessor_common.h
@@ -447,7 +447,6 @@ void check_zero_length_buffer_placeholder_constructor(
   }
 
   for (size_t i = 0; i < conditions_checks_size; i++) {
-    INFO(std::string("conditions_check[")+std::to_string(i) + "]");
     CHECK(conditions_check[i]);
   }
 }

From 3d739d5c46f8ec23ebbcb9ff66c039eec128e978 Mon Sep 17 00:00:00 2001
From: aleks meshkov <alekseix.meshkov@intel.com>
Date: Tue, 27 Jun 2023 10:02:46 +0300
Subject: [PATCH 5/5] Fix clang format

---
 tests/accessor/accessor_common.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/accessor/accessor_common.h b/tests/accessor/accessor_common.h
index 221072cfc..7c8e38918 100644
--- a/tests/accessor/accessor_common.h
+++ b/tests/accessor/accessor_common.h
@@ -490,13 +490,13 @@ void check_zero_length_buffer_constructor(GetAccFunctorT get_accessor_functor) {
           bool check_iterator_methods = false;
           if constexpr (Target == sycl::target::host_task) {
             cgh.host_task([=] {
-              check_empty_accessor_constructor_post_conditions(acc, res_acc,
-                                                               check_iterator_methods);
+              check_empty_accessor_constructor_post_conditions(
+                  acc, res_acc, check_iterator_methods);
             });
           } else if constexpr (Target == sycl::target::device) {
             cgh.parallel_for_work_group(r, [=](sycl::group<Dimension>) {
-              check_empty_accessor_constructor_post_conditions(acc, res_acc,
-                                                               check_iterator_methods);
+              check_empty_accessor_constructor_post_conditions(
+                  acc, res_acc, check_iterator_methods);
             });
           }
         })