diff --git a/ci/adaptivecpp.filter b/ci/adaptivecpp.filter
index 7ec16d937..4798dca26 100644
--- a/ci/adaptivecpp.filter
+++ b/ci/adaptivecpp.filter
@@ -5,7 +5,6 @@ device_selector
 event
 exceptions
 group
-group_functions
 h_item
 handler
 hierarchical
@@ -16,15 +15,12 @@ kernel
 kernel_args
 kernel_bundle
 marray_basic
-marray_pre_post
 math_builtin_api
 multi_ptr
 nd_item
 optional_kernel_features
 property
-queue
 sampler
-scalars
 spec_constants
 stream
 usm
diff --git a/docker/adaptivecpp/configure.sh b/docker/adaptivecpp/configure.sh
index d6c841189..b89bdacd6 100644
--- a/docker/adaptivecpp/configure.sh
+++ b/docker/adaptivecpp/configure.sh
@@ -8,6 +8,7 @@ cmake . -G Ninja -B build \
     -DCMAKE_PREFIX_PATH=/sycl \
     -DCMAKE_BUILD_TYPE=Release \
     -DSYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS=0 \
+    -DSYCL_CTS_ENABLE_HALF_TESTS=0 \
     -DSYCL_CTS_ENABLE_FULL_CONFORMANCE=0 \
     -DSYCL_CTS_ENABLE_DEPRECATED_FEATURES_TESTS=1 \
     $@
diff --git a/tests/accessor_basic/accessor_common.h b/tests/accessor_basic/accessor_common.h
index 7540a2e14..be57404e9 100644
--- a/tests/accessor_basic/accessor_common.h
+++ b/tests/accessor_basic/accessor_common.h
@@ -27,14 +27,10 @@
 #include "../common/common.h"
 #include "../common/once_per_unit.h"
 #include "../common/section_name_builder.h"
+#include "../common/type_coverage.h"
 #include "../common/type_list.h"
 #include "../common/value_operations.h"
 
-// FIXME: re-enable when marrray is implemented in adaptivecpp
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-#include "../common/type_coverage.h"
-#endif
-
 #include <catch2/matchers/catch_matchers.hpp>
 
 namespace accessor_tests_common {
@@ -140,10 +136,6 @@ inline std::string get_section_name(const std::string& type_name,
       .create();
 }
 
-// FIXME: re-enable when marrray is implemented in adaptivecpp and type_coverage
-// is enabled
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 #if SYCL_CTS_ENABLE_HALF_TESTS
 /**
  * @brief Factory function for getting type_pack with fp16 type
@@ -242,8 +234,13 @@ using all_dimensions_pack = integer_pack<0, 1, 2, 3>;
 /**
  * @brief Alias for a value pack containing all tested targets.
  */
+// FIXME: re-enable when host_task is implemented in adaptivecpp
+#ifdef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+using targets_pack = value_pack<sycl::target, sycl::target::device>;
+#else
 using targets_pack =
     value_pack<sycl::target, sycl::target::device, sycl::target::host_task>;
+#endif
 
 /**
  * @brief Lightweight struct for containing tuple types with the singleton packs
@@ -382,7 +379,6 @@ inline auto add_vectors_to_type_pack(StrNameType type_name) {
                                   "vec<" + type_name + ", 8>",
                                   "vec<" + type_name + ", 16>");
 }
-#endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 template <accessor_type AccType>
 struct tag_factory {
@@ -467,7 +463,6 @@ void check_empty_accessor_constructor_post_conditions(
   // All size queries return 0
   res_acc[res_i++] = testing_acc.byte_size() == 0;
   res_acc[res_i++] = testing_acc.size() == 0;
-  res_acc[res_i++] = testing_acc.max_size() == 0;
 
   if (check_iterator_methods) {
     // The only iterator that can be obtained is nullptr
@@ -478,10 +473,6 @@ void check_empty_accessor_constructor_post_conditions(
   }
 }
 
-// FIXME: re-enable when handler.host_task and sycl::errc is implemented in
-// adaptivecpp and computcpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 /**
  * @brief Common function that constructs accessor with default constructor
  *and checks post-conditions
@@ -599,15 +590,21 @@ void check_zero_length_buffer_constructor(GetAccFunctorT get_accessor_functor) {
           // to avoid undefined behavior
           bool check_iterator_methods = false;
           if constexpr (Target == sycl::target::host_task) {
+// FIXME: re-enable when host_task is implemented in adaptivecpp
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
             cgh.host_task([=] {
               check_empty_accessor_constructor_post_conditions(
                   acc, res_acc, check_iterator_methods);
             });
+#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
           } else if constexpr (Target == sycl::target::device) {
+// FIXME: re-enable when parallel_for_work_group is implemented in adaptivecpp
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
             cgh.parallel_for_work_group(sycl::range(1), [=](sycl::group<1>) {
               check_empty_accessor_constructor_post_conditions(
                   acc, res_acc, check_iterator_methods);
             });
+#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
           }
         })
         .wait_and_throw();
@@ -622,7 +619,6 @@ void check_zero_length_buffer_constructor(GetAccFunctorT get_accessor_functor) {
     CHECK(conditions_check[i]);
   }
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 namespace detail {
 /**
@@ -670,9 +666,6 @@ void read_write_zero_dim_acc(AccT testing_acc, ResultAccT res_acc) {
     value_operations::assign(acc_ref, changed_val);
   }
 }
-// FIXME: re-enable when handler.host_task and sycl::errc is implemented in
-// adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 /**
  * @brief Function helps to check zero dimension constructor of accessor
@@ -714,6 +707,8 @@ void check_zero_dim_constructor(GetAccFunctorT get_accessor_functor,
             }
           }
           if constexpr (Target == sycl::target::host_task) {
+// FIXME: re-enable when host_task is implemented in adaptivecpp
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
             cgh.host_task([=] {
               // We are free either to create new accessor instance or to
               // modify original accessor and provide reference to it;
@@ -723,12 +718,16 @@ void check_zero_dim_constructor(GetAccFunctorT get_accessor_functor,
                   (detail::invoke_helper{modify_accessor} = ... = acc);
               read_write_zero_dim_acc<DataT, AccessMode>(acc_instance, res_acc);
             });
+#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
           } else if constexpr (Target == sycl::target::device) {
+// FIXME: re-enable when parallel_for_work_group is implemented in adaptivecpp
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
             cgh.parallel_for_work_group(r, [=](sycl::group<1>) {
               auto&& acc_instance =
                   (detail::invoke_helper{modify_accessor} = ... = acc);
               read_write_zero_dim_acc<DataT, AccessMode>(acc_instance, res_acc);
             });
+#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
           } else {
             static_assert(Target != Target, "Unexpected accessor type");
           }
@@ -759,7 +758,6 @@ void check_zero_dim_constructor(GetAccFunctorT get_accessor_functor,
     }
   }
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 /**
  * @brief Function that tries to read or/and write depending on AccessMode
@@ -787,10 +785,6 @@ void read_write_acc(AccT testing_acc, ResultAccT res_acc) {
   }
 }
 
-// FIXME: re-enable when handler.host_task and sycl::errc is implemented in
-// adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 /**
  * @brief Function helps to check common constructor of accessor
  *
@@ -834,6 +828,8 @@ void check_common_constructor(GetAccFunctorT get_accessor_functor,
           }
 
           if constexpr (Target == sycl::target::host_task) {
+// FIXME: re-enable when host_task is implemented in adaptivecpp
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
             cgh.host_task([=] {
               auto&& acc_instance =
                   (detail::invoke_helper{modify_accessor} = ... = acc);
@@ -845,7 +841,10 @@ void check_common_constructor(GetAccFunctorT get_accessor_functor,
                                                            res_acc);
               }
             });
+#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
           } else if constexpr (Target == sycl::target::device) {
+// FIXME: re-enable when parallel_for_work_group is implemented in adaptivecpp
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
             cgh.parallel_for_work_group(
                 sycl::range(1), [=](sycl::group<1>) {
                   auto&& acc_instance =
@@ -858,6 +857,7 @@ void check_common_constructor(GetAccFunctorT get_accessor_functor,
                                                                res_acc);
                   }
                 });
+#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
           } else {
             static_assert(Target != Target, "Unexpected accessor type");
           }
@@ -893,7 +893,6 @@ void check_common_constructor(GetAccFunctorT get_accessor_functor,
     }
   }
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 /**
  * @brief Function mainly for testing no_init property. The function tries to
@@ -922,8 +921,6 @@ void write_read_acc(AccT testing_acc, ResultAccT res_acc) {
     }
   }
 }
-// FIXME: re-enable when handler.host_task and sycl::errc is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 template <accessor_type AccType, typename DataT, int Dimension,
           sycl::access_mode AccessMode, sycl::target Target>
@@ -956,13 +953,19 @@ void check_no_init_prop(GetAccFunctorT get_accessor_functor) {
           auto acc = get_accessor_functor(data_buf, cgh);
 
           if (Target == sycl::target::host_task) {
+// FIXME: re-enable when host_task is implemented in adaptivecpp
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
             cgh.host_task([=] {
               write_read_acc<DataT, Dimension, AccessMode>(acc, res_acc);
             });
+#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
           } else if (Target == sycl::target::device) {
+// FIXME: re-enable when parallel_for_work_group is implemented in adaptivecpp
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
             cgh.parallel_for_work_group(sycl::range(1), [=](sycl::group<1>) {
               write_read_acc<DataT, Dimension, AccessMode>(acc, res_acc);
             });
+#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
           }
         })
         .wait_and_throw();
@@ -1010,7 +1013,7 @@ void check_no_init_prop_exception(GetAccFunctorT construct_acc) {
     }
   }
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+
 /**
  * @brief Function tests AccT::get_pointer() method
 
@@ -1026,9 +1029,6 @@ void test_accessor_ptr(AccT& accessor, T expected_data) {
   CHECK(value_operations::are_equal(*acc_pointer, expected_data));
 }
 
-// FIXME: re-enable when sycl::access::decorated enumeration is implemented in
-// adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <typename T, typename AccT, typename AccRes>
 void test_accessor_ptr_device(AccT& accessor, T& expected_data, AccRes& res_acc,
                               size_t& res_i) {
@@ -1054,7 +1054,7 @@ void test_accessor_ptr_device(AccT& accessor, T& expected_data, AccRes& res_acc,
                      sycl::global_ptr<typename AccT::value_type>>;
   res_acc[res_i++] = value_operations::are_equal(*acc_pointer, expected_data);
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+
 /**
  * @brief Function checks common buffer and local accessor member functions
  */
@@ -1126,6 +1126,9 @@ void test_accessor_range_methods(const AccT& accessor,
 template <accessor_type AccType, typename DataT, int Dimension, typename PropT,
           typename GetAccFunctorT>
 void check_has_property_member_func(GetAccFunctorT construct_acc) {
+#if SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+  FAIL("AdaptiveCpp does not support get_property on accesors.");
+#else
   constexpr int dim_buf = (0 == Dimension) ? 1 : Dimension;
   const auto r = util::get_cts_object::range<dim_buf>::get(1, 1, 1);
   auto queue = once_per_unit::get_queue();
@@ -1145,6 +1148,7 @@ void check_has_property_member_func(GetAccFunctorT construct_acc) {
     compare_res = acc.template has_property<sycl::property::no_init>();
   }
   CHECK(compare_res);
+#endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 }
 
 /**
@@ -1156,6 +1160,9 @@ void check_has_property_member_func(GetAccFunctorT construct_acc) {
 template <accessor_type AccType, typename DataT, int Dimension,
           typename GetAccFunctorT>
 void check_has_property_member_without_no_init(GetAccFunctorT construct_acc) {
+#if SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+  FAIL("AdaptiveCpp does not support get_property on accesors.");
+#else
   constexpr int dim_buf = (0 == Dimension) ? 1 : Dimension;
   const auto r = util::get_cts_object::range<dim_buf>::get(1, 1, 1);
   auto queue = once_per_unit::get_queue();
@@ -1175,6 +1182,7 @@ void check_has_property_member_without_no_init(GetAccFunctorT construct_acc) {
     compare_res = acc.template has_property<sycl::property::no_init>();
   }
   CHECK(!compare_res);
+#endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 }
 
 /**
@@ -1186,6 +1194,9 @@ void check_has_property_member_without_no_init(GetAccFunctorT construct_acc) {
 template <accessor_type AccType, typename DataT, int Dimension, typename PropT,
           typename GetAccFunctorT>
 void check_get_property_member_func(GetAccFunctorT construct_acc) {
+#if SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+  FAIL("AdaptiveCpp does not support get_property on accesors.");
+#else
   constexpr int dim_buf = (0 == Dimension) ? 1 : Dimension;
   const auto r = util::get_cts_object::range<dim_buf>::get(1, 1, 1);
   auto queue = once_per_unit::get_queue();
@@ -1205,11 +1216,9 @@ void check_get_property_member_func(GetAccFunctorT construct_acc) {
     auto acc_prop = acc.template get_property<PropT>();
     CHECK(std::is_same_v<PropT, decltype(acc_prop)>);
   }
+#endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 }
 
-// FIXME: re-enable when handler.host_task and sycl::errc is implemented in
-// adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 /**
  * @brief Function invokes \c get_property() member function without \c PropT
  * property and verifies that false returns
@@ -1219,6 +1228,9 @@ void check_get_property_member_func(GetAccFunctorT construct_acc) {
 template <accessor_type AccType, typename DataT, int Dimension,
           typename GetAccFunctorT>
 void check_get_property_member_without_no_init(GetAccFunctorT construct_acc) {
+#if SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+  FAIL("AdaptiveCpp does not support get_property on accesors.");
+#else
   constexpr int dim_buf = (0 == Dimension) ? 1 : Dimension;
   const auto r = util::get_cts_object::range<dim_buf>::get(1, 1, 1);
   auto queue = once_per_unit::get_queue();
@@ -1243,8 +1255,8 @@ void check_get_property_member_without_no_init(GetAccFunctorT construct_acc) {
     CHECK_THROWS_MATCHES(action(), sycl::exception,
                          sycl_cts::util::equals_exception(sycl::errc::invalid));
   }
-}
 #endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+}
 /**
  * @brief Function checks common buffer and local accessor member types
  */
@@ -1286,9 +1298,6 @@ sycl::id<dims> next_id_linearly(sycl::id<dims> id, size_t size) {
   return id;
 }
 
-// FIXME: re-enable when handler.host_task is implemented in adaptivecpp
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 template <accessor_type AccType, typename T, int dims,
           sycl::access_mode AccessMode, sycl::target Target>
 class kernel_linearization;
@@ -1339,6 +1348,8 @@ void check_linearization() {
                 }
               });
             } else {
+// FIXME: re-enable when host_task is implemented in adaptivecpp
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
               cgh.host_task([=] {
                 sycl::id<dims> id{};
                 for (auto& elem : acc) {
@@ -1346,6 +1357,7 @@ void check_linearization() {
                   id = next_id_linearly(id, range_size);
                 }
               });
+#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
             }
           })
           .wait_and_throw();
@@ -1361,7 +1373,6 @@ void check_linearization() {
     }
   }
 }
-#endif
 
 template <int dims, typename AccT>
 typename AccT::reference get_accessor_reference(const AccT& acc) {
diff --git a/tests/accessor_basic/accessor_default_values.cpp.in b/tests/accessor_basic/accessor_default_values.cpp.in
index 61a6904d9..58943b05f 100644
--- a/tests/accessor_basic/accessor_default_values.cpp.in
+++ b/tests/accessor_basic/accessor_default_values.cpp.in
@@ -18,21 +18,17 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "accessor_default_values.h"
 
 using namespace accessor_default_values_test;
 using namespace accessor_tests_common;
-#endif
 
 namespace accessor_default_values_test_core {
 using namespace sycl_cts;
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Accessors constructor default values test", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Accessors constructor default values test", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -54,6 +50,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_tests<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace accessor_default_values_test_core
diff --git a/tests/accessor_basic/accessor_exceptions.cpp.in b/tests/accessor_basic/accessor_exceptions.cpp.in
index af67f7c33..52f6a8cd5 100644
--- a/tests/accessor_basic/accessor_exceptions.cpp.in
+++ b/tests/accessor_basic/accessor_exceptions.cpp.in
@@ -17,21 +17,17 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "accessor_exceptions.h"
 
 using namespace accessor_exceptions_test;
 using namespace accessor_tests_common;
-#endif
 
 namespace accessor_exceptions_test_core {
 using namespace sycl_cts;
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor constructor exceptions test.",
- "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor constructor exceptions test.",
+ "[accessor]", test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -54,11 +50,10 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_tests_with_types<CTS_TYPE, generic_accessor, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " sycl::local_accessor constructor exceptions test.",
- "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " sycl::local_accessor constructor exceptions test.",
+ "[accessor]", test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -81,11 +76,10 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_tests_with_types<CTS_TYPE, local_accessor, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " sycl::host_accessor constructor exceptions test.",
- "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " sycl::host_accessor constructor exceptions test.",
+ "[accessor]", test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -108,6 +102,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_tests_with_types<CTS_TYPE, host_accessor, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace accessor_exceptions_test_core
diff --git a/tests/accessor_basic/accessor_exceptions.h b/tests/accessor_basic/accessor_exceptions.h
index 07dc8a5ec..776363d27 100644
--- a/tests/accessor_basic/accessor_exceptions.h
+++ b/tests/accessor_basic/accessor_exceptions.h
@@ -126,7 +126,7 @@ class test_exception_for_local_acc {
             .submit([&](sycl::handler& cgh) {
               sycl::accessor dest_acc{dest, cgh, sycl::write_only};
               sycl::local_accessor<DataT, Dimension> local_acc(range, cgh);
-              cgh.single_task<kname>([=](sycl::kernel_handler cgh) {
+              cgh.single_task<kname>([=]() {
                 // Some interactions to avoid device code optimisation.
                 dest_acc[0] = local_acc.empty();
               });
diff --git a/tests/accessor_basic/accessor_implicit_conversions.cpp.in b/tests/accessor_basic/accessor_implicit_conversions.cpp.in
index a0a20119a..a01c0d63c 100644
--- a/tests/accessor_basic/accessor_implicit_conversions.cpp.in
+++ b/tests/accessor_basic/accessor_implicit_conversions.cpp.in
@@ -13,8 +13,6 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "accessor_common.h"
 #include "accessor_implicit_conversions.h"
@@ -23,16 +21,13 @@ namespace accessor_implicit_conversions_core {
 using namespace accessor_implicit_conversions;
 }  // namespace accessor_implicit_conversions_core
 
-#endif
-
 #include "../common/disabled_for_test_case.h"
 #include "catch2/catch_test_macros.hpp"
 
 namespace accessor_implicit_conversions_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor implicit conversion.",
- "[accessor][generic_accessor][conversion][core]", generic_test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor implicit conversion.",
+ "[accessor][generic_accessor][conversion][core]", generic_test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -54,11 +49,10 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_test_generic<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " The sycl::local_accessor implicit conversion.",
- "[accessor][local_accessor][conversion][core]", host_local_test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " The sycl::local_accessor implicit conversion.",
+ "[accessor][local_accessor][conversion][core]", host_local_test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -80,11 +74,10 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_test_local<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " The sycl::host_accessor implicit conversion.",
- "[accessor][host_accessor][conversion][core]", host_local_test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " The sycl::host_accessor implicit conversion.",
+ "[accessor][host_accessor][conversion][core]", host_local_test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -106,6 +99,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_test_host<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace accessor_implicit_conversions_core
diff --git a/tests/accessor_basic/accessor_iterator_requirement.cpp b/tests/accessor_basic/accessor_iterator_requirement.cpp
index f850c6c69..540c4fa70 100644
--- a/tests/accessor_basic/accessor_iterator_requirement.cpp
+++ b/tests/accessor_basic/accessor_iterator_requirement.cpp
@@ -115,10 +115,10 @@ inline auto fill_errors(std::tuple<ConstructAcc, GetIterator> ftuple) {
   return errors;
 }
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::accessor "
- "iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for sycl::accessor "
+    "iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -129,12 +129,12 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.begin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::accessor "
- "const iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for sycl::accessor "
+    "const iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -145,12 +145,12 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.cbegin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::accessor "
- "reverse iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for sycl::accessor "
+    "reverse iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -161,12 +161,12 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.rbegin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::accessor "
- "const reverse iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for sycl::accessor "
+    "const reverse iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -177,12 +177,13 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.crbegin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::local_accessor "
- "iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for "
+    "sycl::local_accessor "
+    "iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -194,12 +195,13 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.begin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::local_accessor "
- "const iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for "
+    "sycl::local_accessor "
+    "const iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -211,12 +213,13 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.cbegin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::local_accessor "
- "reverse iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for "
+    "sycl::local_accessor "
+    "reverse iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -228,12 +231,13 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.rbegin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::local_accessor "
- "const reverse iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for "
+    "sycl::local_accessor "
+    "const reverse iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -245,12 +249,13 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.crbegin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::host_accessor "
- "iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for "
+    "sycl::host_accessor "
+    "iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -262,12 +267,13 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.begin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::host_accessor "
- "const iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for "
+    "sycl::host_accessor "
+    "const iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -279,12 +285,13 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.cbegin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::host_accessor "
- "reverse iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for "
+    "sycl::host_accessor "
+    "reverse iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -296,12 +303,13 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.rbegin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("LegacyRandomAccessIterator requirement verification for sycl::host_accessor "
- "const reverse iterator",
- "[accessor]")({
+TEST_CASE(
+    "LegacyRandomAccessIterator requirement verification for "
+    "sycl::host_accessor "
+    "const reverse iterator",
+    "[accessor]") {
   using namespace sycl_cts;
   using namespace named_requirement_verification;
 
@@ -313,6 +321,6 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
       [](auto& dummy_acc) { return dummy_acc.crbegin(); });
   auto errors = fill_errors(t);
   print_errors(errors);
-});
+}
 
 }  // namespace accessor_iterator_requirement
diff --git a/tests/accessor_generic/generic_accessor_api.cpp.in b/tests/accessor_generic/generic_accessor_api.cpp.in
index 6cdf244f6..0f6bb5250 100644
--- a/tests/accessor_generic/generic_accessor_api.cpp.in
+++ b/tests/accessor_generic/generic_accessor_api.cpp.in
@@ -13,19 +13,15 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_api_common.h"
 
 using namespace generic_accessor_api_common;
-#endif
 
 namespace generic_accessor_api_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor api.", "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor api.", "[accessor]", test_combinations){
   using namespace generic_accessor_api_common;
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
@@ -49,6 +45,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_api_for_type<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_api_core
diff --git a/tests/accessor_generic/generic_accessor_api_common.h b/tests/accessor_generic/generic_accessor_api_common.h
index b8b27a45d..16ffe0210 100644
--- a/tests/accessor_generic/generic_accessor_api_common.h
+++ b/tests/accessor_generic/generic_accessor_api_common.h
@@ -221,6 +221,8 @@ class run_api_tests {
               }
 
               if constexpr (Target == sycl::target::host_task) {
+// FIXME: re-enable when host_task is implemented in adaptivecpp
+#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
                 cgh.host_task([=] {
                   test_accessor_ptr_host(acc, expected_val);
                   test_begin_end_host(acc, expected_val, expected_val, false);
@@ -257,6 +259,7 @@ class run_api_tests {
                     }
                   }
                 });
+#endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
               } else {
                 using kname =
                     kernel_buffer_accessor<T, AccessT, DimensionT, TargetT>;
@@ -382,6 +385,8 @@ class run_api_tests {
                                             offset_id /*&expected_offset*/);
 
                 if constexpr (Target == sycl::target::host_task) {
+// FIXME: re-enable when host_task is implemented in adaptivecpp
+#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
                   cgh.host_task([=] {
                     test_accessor_ptr_host(acc, T());
                     test_begin_end_host(
@@ -397,6 +402,7 @@ class run_api_tests {
                       value_operations::assign(acc_ref2, expected_val);
                     }
                   });
+#endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
                 } else {
                   using kname = kernel_offset<T, AccessT, DimensionT, TargetT>;
                   sycl::accessor res_acc(res_buf, cgh);
@@ -453,6 +459,8 @@ class run_api_tests {
               AccT acc2(data_buf2, cgh);
               acc1.swap(acc2);
               if constexpr (Target == sycl::target::host_task) {
+// FIXME: re-enable when host_task is implemented in adaptivecpp
+#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
                 cgh.host_task([=] {
                   typename AccT::reference acc_ref1 =
                       get_accessor_reference<dims>(acc1);
@@ -465,6 +473,7 @@ class run_api_tests {
                     value_operations::assign(acc_ref2, changed_val);
                   }
                 });
+#endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
               } else {
                 using kname = kernel_swap<T, AccessT, DimensionT, TargetT>;
                 sycl::accessor res_acc(res_buf, cgh);
diff --git a/tests/accessor_generic/generic_accessor_common_buffer_constructors.cpp.in b/tests/accessor_generic/generic_accessor_common_buffer_constructors.cpp.in
index 7f17cba9f..df5db34c3 100644
--- a/tests/accessor_generic/generic_accessor_common_buffer_constructors.cpp.in
+++ b/tests/accessor_generic/generic_accessor_common_buffer_constructors.cpp.in
@@ -28,21 +28,17 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_common_buffer_constructors.h"
 
 using namespace generic_accessor_common_buffer_constructors;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_common_buffer_constructors_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor buffer constructors.", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor buffer constructors.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -66,6 +62,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_common_buffer_constructors_test<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_common_buffer_constructors_core
diff --git a/tests/accessor_generic/generic_accessor_common_buffer_tag_constructors.cpp.in b/tests/accessor_generic/generic_accessor_common_buffer_tag_constructors.cpp.in
index 16b4e20b1..3fb5436d4 100644
--- a/tests/accessor_generic/generic_accessor_common_buffer_tag_constructors.cpp.in
+++ b/tests/accessor_generic/generic_accessor_common_buffer_tag_constructors.cpp.in
@@ -28,21 +28,17 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_common_buffer_tag_constructors.h"
 
 using namespace generic_accessor_common_buffer_tag_constructors;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_common_buffer_tag_constructors_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor buffer tag constructors.", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor buffer tag constructors.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -67,6 +63,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
   run_generic_common_buffer_tag_constructors_test<CTS_TYPE, TestType>{}(
       CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_common_buffer_tag_constructors_core
diff --git a/tests/accessor_generic/generic_accessor_def_constructor.cpp.in b/tests/accessor_generic/generic_accessor_def_constructor.cpp.in
index 90dd68312..13ef380c0 100644
--- a/tests/accessor_generic/generic_accessor_def_constructor.cpp.in
+++ b/tests/accessor_generic/generic_accessor_def_constructor.cpp.in
@@ -27,21 +27,17 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_def_constructor.h"
 
 using namespace generic_accessor_def_constructor;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_def_constructor_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor def constructors.", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor def constructors.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -64,6 +60,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_def_constructor_test<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_def_constructor_core
diff --git a/tests/accessor_generic/generic_accessor_linearization.cpp.in b/tests/accessor_generic/generic_accessor_linearization.cpp.in
index b72b077d4..83c40d814 100644
--- a/tests/accessor_generic/generic_accessor_linearization.cpp.in
+++ b/tests/accessor_generic/generic_accessor_linearization.cpp.in
@@ -27,23 +27,19 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_linearization.h"
 
 using namespace generic_accessor_linearization;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 #include "catch2/catch_test_macros.hpp"
 
 namespace generic_accessor_linearization_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor linearization test.", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor linearization test.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -66,6 +62,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_linearization_for_type<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_linearization_core
diff --git a/tests/accessor_generic/generic_accessor_properties.cpp.in b/tests/accessor_generic/generic_accessor_properties.cpp.in
index 8d6a354ff..ccf2edc82 100644
--- a/tests/accessor_generic/generic_accessor_properties.cpp.in
+++ b/tests/accessor_generic/generic_accessor_properties.cpp.in
@@ -13,23 +13,19 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_properties.h"
 
 using namespace generic_accessor_properties;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 #include "catch2/catch_test_macros.hpp"
 
 namespace generic_accessor_properties_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor properties test.", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor properties test.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -52,6 +48,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_properties_tests<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_properties_core
diff --git a/tests/accessor_generic/generic_accessor_semantics.cpp b/tests/accessor_generic/generic_accessor_semantics.cpp
index d6a23ac07..0a74b7b5e 100644
--- a/tests/accessor_generic/generic_accessor_semantics.cpp
+++ b/tests/accessor_generic/generic_accessor_semantics.cpp
@@ -20,9 +20,7 @@
 
 #include "../common/common.h"
 #include "../common/disabled_for_test_case.h"
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #include "../common/semantics_reference.h"
-#endif
 
 template <int Dimensions>
 struct storage {
@@ -171,8 +169,8 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
   }
 });
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("generic accessor common reference semantics (kernel)", "[accessor]")({
+TEST_CASE("generic accessor common reference semantics (kernel)",
+          "[accessor]") {
   sycl::buffer<int> buffer{sycl::range<1>{1}};
   using type =
       sycl::accessor<int, 1, sycl::access_mode::read_write,
@@ -184,14 +182,13 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
                 cgh);
       },
       "accessor<int, 1, access_mode::read_write, target::device>");
-});
+}
 
 template <int TestCase>
 class kernel_name_generic;
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("generic accessor common reference semantics, mutation (kernel)",
- "[accessor]")({
+TEST_CASE("generic accessor common reference semantics, mutation (kernel)",
+          "[accessor]") {
   sycl::queue queue = sycl_cts::util::get_cts_object::queue();
   int result = 0;
 
@@ -255,4 +252,4 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
     }
     CHECK(new_val == result);
   }
-});
+};
diff --git a/tests/accessor_generic/generic_accessor_zero_dim_constructor.cpp.in b/tests/accessor_generic/generic_accessor_zero_dim_constructor.cpp.in
index 79997b3e2..e55b3e7d7 100644
--- a/tests/accessor_generic/generic_accessor_zero_dim_constructor.cpp.in
+++ b/tests/accessor_generic/generic_accessor_zero_dim_constructor.cpp.in
@@ -28,22 +28,18 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_zero_dim_constructor.h"
 
 using namespace generic_accessor_zero_dim_constructor;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_zero_dim_constructor_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor zero-dim constructors.", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor zero-dim constructors.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -66,6 +62,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_zero_dim_constructor_test<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_zero_dim_constructor_core
diff --git a/tests/accessor_placeholder/generic_accessor_placeholder_buffer_constructor.cpp.in b/tests/accessor_placeholder/generic_accessor_placeholder_buffer_constructor.cpp.in
index ad9089bce..9b0bd3ecf 100644
--- a/tests/accessor_placeholder/generic_accessor_placeholder_buffer_constructor.cpp.in
+++ b/tests/accessor_placeholder/generic_accessor_placeholder_buffer_constructor.cpp.in
@@ -28,22 +28,18 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_placeholder_buffer_constructor.h"
 
 using namespace generic_accessor_placeholder_buffer_constructor;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_placeholder_buffer_constructor_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor placeholder constructors.", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor placeholder constructors.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -67,6 +63,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_placeholder_buffer_constructor_test<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_placeholder_buffer_constructor_core
diff --git a/tests/accessor_placeholder/generic_accessor_placeholder_buffer_range_constructor.cpp.in b/tests/accessor_placeholder/generic_accessor_placeholder_buffer_range_constructor.cpp.in
index 32b3c797d..53b884c94 100644
--- a/tests/accessor_placeholder/generic_accessor_placeholder_buffer_range_constructor.cpp.in
+++ b/tests/accessor_placeholder/generic_accessor_placeholder_buffer_range_constructor.cpp.in
@@ -28,22 +28,18 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_placeholder_buffer_range_constructor.h"
 
 using namespace generic_accessor_placeholder_buffer_range_constructor;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_placeholder_buffer_range_constructor_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor placeholder buffer range constructor.",
- "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor placeholder buffer range constructor.",
+ "[accessor]", test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -68,6 +64,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_placeholder_buffer_range_constructor_test<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_placeholder_buffer_range_constructor_core
diff --git a/tests/accessor_placeholder/generic_accessor_placeholder_buffer_range_offset_constructor.cpp.in b/tests/accessor_placeholder/generic_accessor_placeholder_buffer_range_offset_constructor.cpp.in
index b9dea6a57..75d4223fa 100644
--- a/tests/accessor_placeholder/generic_accessor_placeholder_buffer_range_offset_constructor.cpp.in
+++ b/tests/accessor_placeholder/generic_accessor_placeholder_buffer_range_offset_constructor.cpp.in
@@ -28,22 +28,18 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_placeholder_buffer_range_offset_constructor.h"
 
 using namespace generic_accessor_placeholder_buffer_range_offset_constructor;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_placeholder_buffer_range_offset_constructor_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor placeholder buffer range offset constructor.",
- "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor placeholder buffer range offset constructor.",
+ "[accessor]", test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -69,7 +65,7 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_placeholder_buffer_range_offset_constructor_test<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace
    // generic_accessor_placeholder_buffer_range_offset_constructor_core
diff --git a/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_constructor.cpp.in b/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_constructor.cpp.in
index c98b2aa88..c085cf31e 100644
--- a/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_constructor.cpp.in
+++ b/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_constructor.cpp.in
@@ -28,22 +28,18 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_placeholder_zero_length_buffer_constructor.h"
 
 using namespace generic_accessor_placeholder_zero_length_buffer_constructor;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_placeholder_zero_length_buffer_constructor_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor placeholder zero-length buffer constructor.",
- "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor placeholder zero-length buffer constructor.",
+ "[accessor]", test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -69,6 +65,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_placeholder_zero_length_buffer_constructor<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace generic_accessor_placeholder_zero_length_buffer_constructor_core
diff --git a/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_range_constructor.cpp.in b/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_range_constructor.cpp.in
index 82eca8f23..1371167ca 100644
--- a/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_range_constructor.cpp.in
+++ b/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_range_constructor.cpp.in
@@ -28,22 +28,18 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_placeholder_zero_length_buffer_range_constructor.h"
 
 using namespace generic_accessor_placeholder_zero_length_buffer_range_constructor;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_placeholder_zero_length_buffer_range_constructor_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor placeholder zero-length buffer range constructor. ",
- "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor placeholder zero-length buffer range constructor. ",
+ "[accessor]", test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -68,7 +64,7 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_generic_placeholder_zero_length_buffer_range_constructor_test<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace
    // generic_accessor_placeholder_zero_length_buffer_range_constructor_core
diff --git a/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor.cpp.in b/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor.cpp.in
index 9b1e8fc1b..6e77d971c 100644
--- a/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor.cpp.in
+++ b/tests/accessor_placeholder/generic_accessor_placeholder_zero_length_buffer_range_offset_constructor.cpp.in
@@ -28,23 +28,19 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #include "../accessor_basic/accessor_common.h"
 #include "generic_accessor_placeholder_zero_length_buffer_range_offset_constructor.h"
 
 using namespace generic_accessor_placeholder_zero_length_buffer_range_offset_constructor;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 
 namespace generic_accessor_placeholder_zero_length_buffer_range_offset_constructor_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " Generic sycl::accessor placeholder zero-length buffer range offset "
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " Generic sycl::accessor placeholder zero-length buffer range offset "
  "constructor.",
- "[accessor]", test_combinations)({
+ "[accessor]", test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -70,7 +66,7 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
   run_generic_placeholder_zero_length_buffer_range_offset_constructor_test<
       CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace
    // generic_accessor_placeholder_zero_length_buffer_range_offset_constructor_core
diff --git a/tests/address_space/address_space_common.h b/tests/address_space/address_space_common.h
index 70ffa4e4c..a942bb755 100644
--- a/tests/address_space/address_space_common.h
+++ b/tests/address_space/address_space_common.h
@@ -180,8 +180,6 @@ class check_types {
           bool pass = true;
           localAcc[0] = initAcc[2];
           T priv = initAcc[3];
-// FIXME: re-enable when sycl::access::decorated is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
           pass &= test_duplication(
               globalAcc
                   .template get_multi_ptr<sycl::access::decorated::legacy>(),
@@ -198,7 +196,6 @@ class check_types {
               localAcc.get_pointer(), constAcc.get_pointer(),
               sycl::private_ptr<T>(&priv));
           resAcc[0] = pass;
-#endif
         });
       });
     }
diff --git a/tests/bit_cast/bit_cast_test_core.cpp b/tests/bit_cast/bit_cast_test_core.cpp
index 24f4d886c..443732b09 100644
--- a/tests/bit_cast/bit_cast_test_core.cpp
+++ b/tests/bit_cast/bit_cast_test_core.cpp
@@ -22,21 +22,15 @@
 #include "../common/disabled_for_test_case.h"
 #include "catch2/catch_test_macros.hpp"
 
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 #include "bit_cast_test.h"
 
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 namespace bit_cast::tests::core {
 
-// FIXME: re-enable when sycl::bit_cast() is implemented in AdaptiveCpp
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("Test sycl::bit_cast, core types", "[bit_cast]")({
+TEST_CASE("Test sycl::bit_cast, core types", "[bit_cast]") {
   const auto primary_types =
       bit_cast::tests::helper_functions::get_primary_type_pack();
   for_all_combinations<bit_cast::tests::run_bit_cast_test>(primary_types,
                                                            primary_types);
-});
+}
 
 }  // namespace bit_cast::tests::core
diff --git a/tests/bit_cast/bit_cast_test_core_fp64.cpp b/tests/bit_cast/bit_cast_test_core_fp64.cpp
index 286bc368d..263f54052 100644
--- a/tests/bit_cast/bit_cast_test_core_fp64.cpp
+++ b/tests/bit_cast/bit_cast_test_core_fp64.cpp
@@ -22,17 +22,11 @@
 #include "../common/disabled_for_test_case.h"
 #include "catch2/catch_test_macros.hpp"
 
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 #include "bit_cast_test.h"
 
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 namespace bit_cast::tests::fp64 {
 
-// FIXME: re-enable when sycl::bit_cast() is implemented in AdaptiveCpp
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("Test sycl::bit_cast, fp64 type", "[bit_cast]")({
+TEST_CASE("Test sycl::bit_cast, fp64 type", "[bit_cast]") {
   auto queue = sycl_cts::util::get_cts_object::queue();
   if (!queue.get_device().has(sycl::aspect::fp64)) {
     SKIP(
@@ -51,6 +45,6 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
                                                            primary_fp64_type);
   for_all_combinations<bit_cast::tests::run_bit_cast_test>(primary_fp64_type,
                                                            primary_fp64_type);
-});
+}
 
 }  // namespace bit_cast::tests::fp64
diff --git a/tests/common/get_group_range.h b/tests/common/get_group_range.h
index b9eb1223b..c0e9097ee 100644
--- a/tests/common/get_group_range.h
+++ b/tests/common/get_group_range.h
@@ -61,16 +61,9 @@ sycl::range<Dimensions> work_group_range(
   // query device for work-group sizes
   size_t max_work_item_sizes[Dimensions];
   {
-    // FIXME: AdaptiveCpp does not implement
-    //        sycl::info::device::max_work_item_sizes<3> property
-#if SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-    sycl::id<3> sizes =
-        queue.get_device().get_info<sycl::info::device::max_work_item_sizes>();
-#else
     sycl::id<3> sizes =
         queue.get_device()
-            .get_info<sycl::info::device::max_work_item_sizes<3> >();
-#endif
+            .get_info<sycl::info::device::max_work_item_sizes<3>>();
     for (int i = 0; i < Dimensions; ++i) {
       max_work_item_sizes[i] = sizes.get(i);
     }
diff --git a/tests/common/type_coverage.h b/tests/common/type_coverage.h
index 85dc847cd..37ee2b55a 100644
--- a/tests/common/type_coverage.h
+++ b/tests/common/type_coverage.h
@@ -57,8 +57,6 @@ struct type_name_string<sycl::vec<T, nElements>> {
   }
 };
 
-// FIXME: re-enable when marray is implemented in adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 /**
  * @brief Specialization of type name retrieve for sycl::marray class
  * @param T Type of the data stored in marray
@@ -70,7 +68,6 @@ struct type_name_string<sycl::marray<T, nElements>> {
     return "sycl::marray<" + dataType + "," + std::to_string(nElements) + ">";
   }
 };
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 /**
  * @brief Specialization of type name retrieve for std::array class
@@ -457,8 +454,6 @@ void for_all_types_and_vectors(const named_type_pack<types...> &typeList,
   assert((typeNameIndex == sizeof...(types)) && "Pack expansion failed");
 }
 
-// FIXME: re-enable when marray is implemented in adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 /**
  * @brief Run action for type, vectors and marrays of this type
  * @tparam action Functor template for action to run
@@ -540,10 +535,7 @@ void for_type_vectors_marray_reduced(argsT&&... args) {
         std::forward<argsT>(args)...);
   }
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
-// FIXME: re-enable when marray is implemented in adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 /**
  * @brief Run action for each of types, vectors and marrays of types given by
  *        named_type_pack instance
@@ -571,10 +563,7 @@ void for_all_types_vectors_marray(const named_type_pack<types...> &typeList,
   // Ensure there is no silent miss for coverage
   assert((typeNameIndex == sizeof...(types)) && "Pack expansion failed");
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
-// FIXME: re-enable when marray is implemented in adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 /**
  * @brief Run action for type and marrays of this type
  * @tparam action Functor template for action to run
@@ -592,10 +581,7 @@ void for_type_and_marrays(argsT &&...args) {
                 typename sycl::template marray<T, 10>>{},
       std::forward<argsT>(args)...);
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
-// FIXME: re-enable when marray is implemented in adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 /**
  * @brief Run action for marrays of type T
  * @tparam action Functor template for action to run
@@ -613,10 +599,7 @@ void for_marrays_of_type(argsT&&... args) {
                 typename sycl::template marray<T, 10>>{},
       std::forward<argsT>(args)...);
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
-// FIXME: re-enable when marray is implemented in adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 /**
  * @brief Run action for each of types and marrays of types given by
  *        named_type_pack instance
@@ -641,10 +624,7 @@ void for_all_types_and_marrays(const named_type_pack<types...> &typeList,
     ++typeNameIndex),
    ...);
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
-// FIXME: re-enable when marray is implemented in adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 /**
  * @brief Run action for marrays of each type of types given by
  *        named_type_pack instance
@@ -669,5 +649,4 @@ void for_marrays_of_all_types(const named_type_pack<types...>& typeList,
     ++typeNameIndex),
    ...);
 }
-#endif  // !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #endif  // __SYCLCTS_TESTS_COMMON_TYPE_COVERAGE_H
diff --git a/tests/host_accessor/host_accessor_api.cpp.in b/tests/host_accessor/host_accessor_api.cpp.in
index f16881222..95403faa8 100644
--- a/tests/host_accessor/host_accessor_api.cpp.in
+++ b/tests/host_accessor/host_accessor_api.cpp.in
@@ -13,18 +13,15 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::host_accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #include "../accessor_basic/accessor_common.h"
 #include "host_accessor_api_common.h"
 
 using namespace host_accessor_api_common;
-#endif
 
 namespace host_accessor_api_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " sycl::host_accessor api.", "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " sycl::host_accessor api.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -47,6 +44,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_host_accessor_api_for_type<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace host_accessor_api_core
diff --git a/tests/host_accessor/host_accessor_constructors.cpp.in b/tests/host_accessor/host_accessor_constructors.cpp.in
index d13f2c793..328adcd39 100644
--- a/tests/host_accessor/host_accessor_constructors.cpp.in
+++ b/tests/host_accessor/host_accessor_constructors.cpp.in
@@ -27,22 +27,18 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::host_accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #include "../accessor_basic/accessor_common.h"
 #include "host_accessor_constructors.h"
 
 using namespace host_accessor_constructors;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 #include "catch2/catch_test_macros.hpp"
 
 namespace host_accessor_constructors_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " sycl::host_accessor constructors.", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " sycl::host_accessor constructors.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -65,6 +61,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_host_constructors_test<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace host_accessor_constructors_core
diff --git a/tests/host_accessor/host_accessor_linearization.cpp.in b/tests/host_accessor/host_accessor_linearization.cpp.in
index 9f81c20b5..eb4b242ef 100644
--- a/tests/host_accessor/host_accessor_linearization.cpp.in
+++ b/tests/host_accessor/host_accessor_linearization.cpp.in
@@ -27,20 +27,15 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::host_accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 #include "../accessor_basic/accessor_common.h"
 #include "host_accessor_linearization.h"
 
 using namespace host_accessor_linearization;
-#endif
 
 namespace host_accessor_liniarization_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " sycl::host_accessor linearization.", "[accessor]",
- test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " sycl::host_accessor linearization.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -63,6 +58,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_host_linearization_for_type<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace host_accessor_liniarization_core
diff --git a/tests/host_accessor/host_accessor_properties.cpp.in b/tests/host_accessor/host_accessor_properties.cpp.in
index 5db33949e..08380a10e 100644
--- a/tests/host_accessor/host_accessor_properties.cpp.in
+++ b/tests/host_accessor/host_accessor_properties.cpp.in
@@ -13,21 +13,18 @@
 #cmakedefine CTS_TYPE_NAME std::string("@CTS_TYPE_NAME@")
 // clang-format on
 
-// FIXME: re-enable when sycl::host_accessor is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #include "../accessor_basic/accessor_common.h"
 #include "host_accessor_properties.h"
 
 using namespace host_accessor_properties;
-#endif
 
 #include "../common/disabled_for_test_case.h"
 #include "catch2/catch_test_macros.hpp"
 
 namespace host_accessor_properties_core {
 
-DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
-(CTS_TYPE_NAME + " sycl::host_accessor properties.", "[accessor]", test_combinations)({
+TEMPLATE_LIST_TEST_CASE(CTS_TYPE_NAME + " sycl::host_accessor properties.", "[accessor]",
+ test_combinations){
   auto queue = sycl_cts::util::get_cts_object::queue();
   if constexpr (std::is_same_v<std::remove_cv_t<CTS_TYPE>, sycl::half>) {
     if (!queue.get_device().has(sycl::aspect::fp16))
@@ -50,6 +47,6 @@ DISABLED_FOR_TEMPLATE_LIST_TEST_CASE(AdaptiveCpp)
 #else
   run_host_properties_tests<CTS_TYPE, TestType>{}(CTS_TYPE_NAME);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
-});
+}
 
 }  // namespace host_accessor_properties_core
diff --git a/tests/host_accessor/host_accessor_semantics.cpp b/tests/host_accessor/host_accessor_semantics.cpp
index baf6b41aa..435789343 100644
--- a/tests/host_accessor/host_accessor_semantics.cpp
+++ b/tests/host_accessor/host_accessor_semantics.cpp
@@ -20,9 +20,7 @@
 
 #include "../common/common.h"
 #include "../common/disabled_for_test_case.h"
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #include "../common/semantics_reference.h"
-#endif
 
 template <int Dimensions>
 struct storage {
@@ -56,8 +54,7 @@ struct storage {
   }
 };
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("host_accessor common reference semantics", "[host_accessor]")({
+TEST_CASE("host_accessor common reference semantics", "[host_accessor]") {
   sycl::buffer<int> buffer_0{sycl::range<1>{1}};
   sycl::host_accessor<int> host_accessor_0{buffer_0};
 
@@ -65,10 +62,10 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
   sycl::host_accessor<int> host_accessor_1{buffer_1};
   common_reference_semantics::check_host<storage<1>>(
       host_accessor_0, host_accessor_1, "host_accessor");
-});
+}
 
-DISABLED_FOR_TEST_CASE(AdaptiveCpp)
-("host_accessor common reference semantics, mutation", "[host_accessor]")({
+TEST_CASE("host_accessor common reference semantics, mutation",
+          "[host_accessor]") {
   constexpr int val = 1;
   constexpr int new_val = 2;
   sycl::buffer<int> buffer{sycl::range<1>{1}};
@@ -94,4 +91,4 @@ DISABLED_FOR_TEST_CASE(AdaptiveCpp)
     t0[0] = new_val;
     CHECK(new_val == t1[0]);
   }
-});
+}
diff --git a/util/math_helper.h b/util/math_helper.h
index 94dc2bdb9..8210a0e61 100644
--- a/util/math_helper.h
+++ b/util/math_helper.h
@@ -72,13 +72,10 @@ int numElements(const sycl::vec<T, numElems> &) {
 
 /* Generic function for both scalar and marray types to
  * return the number of elements in a type. */
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <typename T, size_t numElems>
 int numElements(const sycl::marray<T, numElems> &) {
   return numElems;
 }
-#endif
 
 /* Generic function for both scalar and vector types to
  * extract an individual element. */
@@ -94,15 +91,12 @@ T getElement(sycl::vec<T, dim> &f, int ix) {
   return f[ix];
 }
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 /* Generic function for both scalar and vector types to
  * extract an individual element. */
 template <typename T, size_t dim>
 T getElement(sycl::marray<T, dim> &f, size_t ix) {
   return f[ix];
 }
-#endif
 
 template <typename T, int dim>
 void setElement(sycl::vec<T, dim> &f, int ix, T value) {
@@ -118,8 +112,6 @@ sycl::vec<R, N> run_func_on_vector(funT fun, Args... args) {
   return res;
 }
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <typename R, typename T, size_t N, typename funT, typename... Args>
 sycl::marray<R, N> run_func_on_marray(funT fun, Args... args) {
   sycl::marray<R, N> res;
@@ -128,7 +120,6 @@ sycl::marray<R, N> run_func_on_marray(funT fun, Args... args) {
   }
   return res;
 }
-#endif
 
 /* helper for relational functions where true result gives 1 for scalar
     and -1 for vector argument types */
@@ -144,8 +135,6 @@ sycl::vec<R, N> run_rel_func_on_vector(funT fun, Args... args) {
   return res;
 }
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <typename T, size_t N, typename funT, typename... Args>
 sycl::marray<bool, N> run_rel_func_on_marray(funT fun, Args... args) {
   sycl::marray<bool, N> res;
@@ -154,7 +143,6 @@ sycl::marray<bool, N> run_rel_func_on_marray(funT fun, Args... args) {
   }
   return res;
 }
-#endif
 
 template <typename T, int N, typename funT, typename... Args>
 sycl_cts::resultRef<sycl::vec<T, N>>
@@ -172,8 +160,6 @@ run_func_on_vector_result_ref(funT fun, Args... args) {
   return sycl_cts::resultRef<sycl::vec<T, N>>(res, undefined);
 }
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <typename T, size_t N, typename funT, typename... Args>
 sycl_cts::resultRef<sycl::marray<T, N>> run_func_on_marray_result_ref(
     funT fun, Args... args) {
@@ -188,7 +174,6 @@ sycl_cts::resultRef<sycl::marray<T, N>> run_func_on_marray_result_ref(
   }
   return sycl_cts::resultRef<sycl::marray<T, N>>(res, undefined);
 }
-#endif
 
 template <typename T>
 struct rel_funcs_return;
@@ -219,13 +204,10 @@ rel_func_dispatcher(sycl::vec<T, N> a, Args... args) {
       funT<T>{}, a, args...);
 }
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <template <class> class funT, typename T, size_t N, typename... Args>
 sycl::marray<bool, N> rel_func_dispatcher(sycl::marray<T, N> a, Args... args) {
   return run_rel_func_on_marray<T, N>(funT<T>{}, a, args...);
 }
-#endif
 
 template <typename funT, typename T, typename... Args>
 typename rel_funcs_return<T>::type rel_func_dispatcher(funT fun, T a,
@@ -240,14 +222,11 @@ rel_func_dispatcher(funT fun, sycl::vec<T, N> a, Args... args) {
       fun, a, args...);
 }
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <typename funT, typename T, size_t N, typename... Args>
 sycl::marray<bool, N> rel_func_dispatcher(funT fun, sycl::marray<T, N> a,
                                           Args... args) {
   return run_rel_func_on_marray<T, N>(fun, a, args...);
 }
-#endif
 
 template <typename T>
 int32_t num_bits(T) {
diff --git a/util/math_reference.cpp b/util/math_reference.cpp
index aa8fc8929..9a38dd285 100644
--- a/util/math_reference.cpp
+++ b/util/math_reference.cpp
@@ -456,8 +456,6 @@ sycl::vec<T, N> cross_t(sycl::vec<T, N> a, sycl::vec<T, N> b) {
 sycl::float4 cross(sycl::float4 p0, sycl::float4 p1) { return cross_t(p0, p1); }
 sycl::float3 cross(sycl::float3 p0, sycl::float3 p1) { return cross_t(p0, p1); }
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <typename T, size_t N>
 sycl::marray<T, N> cross_t(sycl::marray<T, N> a, sycl::marray<T, N> b) {
   sycl::marray<T, N> res;
@@ -478,7 +476,6 @@ sycl::mfloat4 cross(sycl::mfloat4 p0, sycl::mfloat4 p1) {
 sycl::mfloat3 cross(sycl::mfloat3 p0, sycl::mfloat3 p1) {
   return cross_t(p0, p1);
 }
-#endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 
 #if SYCL_CTS_ENABLE_HALF_TESTS
 
@@ -516,9 +513,6 @@ sycl::half fma(sycl::half a, sycl::half b, sycl::half c) {
   return reference_fma(a, b, c, 0);
 }
 
-// AdaptiveCpp does not yet support sycl::bit_cast, which is used in
-// `nextafter`.
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 sycl::half fdim(sycl::half a, sycl::half b) {
   if (a > b) {
     // to get rounding to nearest even
@@ -535,7 +529,6 @@ sycl::half fdim(sycl::half a, sycl::half b) {
   }
   return +0;
 }
-#endif
 
 sycl::half fract(sycl::half a, sycl::half* b) {
   *b = std::floor(a);
@@ -551,8 +544,6 @@ sycl::half modf(sycl::half a, sycl::half* b) {
   return res;
 }
 
-// AdaptiveCpp does not yet support sycl::bit_cast
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 sycl::half nextafter(sycl::half x, sycl::half y) {
   if (std::isnan(x)) return x;
 
@@ -578,7 +569,6 @@ sycl::half nextafter(sycl::half x, sycl::half y) {
 
   return sycl::bit_cast<sycl::half>(a);
 }
-#endif
 
 sycl::half sinpi(sycl::half a) { return reference_sinpi(a); }
 sycl::half tanpi(sycl::half a) { return reference_tanpi(a); }
@@ -594,8 +584,6 @@ sycl::half fast_dot(sycl::float4 p0) {
   return std::pow(p0.x(), 2) + std::pow(p0.y(), 2) + std::pow(p0.z(), 2) +
          std::pow(p0.w(), 2);
 }
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 sycl::half fast_dot(sycl::mfloat2 p0) {
   return std::pow(p0[0], 2) + std::pow(p0[1], 2);
 }
@@ -606,7 +594,6 @@ sycl::half fast_dot(sycl::mfloat4 p0) {
   return std::pow(p0[0], 2) + std::pow(p0[1], 2) + std::pow(p0[2], 2) +
          std::pow(p0[3], 2);
 }
-#endif
 
 #endif  // SYCL_CTS_ENABLE_HALF_TESTS
 
@@ -655,15 +642,12 @@ sycl::double4 cross(sycl::double4 p0, sycl::double4 p1) {
 sycl::double3 cross(sycl::double3 p0, sycl::double3 p1) {
   return cross_t(p0, p1);
 }
-
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 sycl::mdouble4 cross(sycl::mdouble4 p0, sycl::mdouble4 p1) {
   return cross_t(p0, p1);
 }
 sycl::mdouble3 cross(sycl::mdouble3 p0, sycl::mdouble3 p1) {
   return cross_t(p0, p1);
 }
-#endif
 
 #endif  // SYCL_CTS_ENABLE_DOUBLE_TESTS
 
diff --git a/util/math_reference.h b/util/math_reference.h
index 48d866312..112dd6259 100644
--- a/util/math_reference.h
+++ b/util/math_reference.h
@@ -665,11 +665,8 @@ T divide(T a, T b) {
 sycl::float4 cross(sycl::float4 p0, sycl::float4 p1);
 sycl::float3 cross(sycl::float3 p0, sycl::float3 p1);
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 sycl::mfloat4 cross(sycl::mfloat4 p0, sycl::mfloat4 p1);
 sycl::mfloat3 cross(sycl::mfloat3 p0, sycl::mfloat3 p1);
-#endif
 
 template <typename T>
 T dot(T p0, T p1) {
@@ -715,32 +712,25 @@ sycl::vec<sycl::half, N> nan(sycl::vec<unsigned short, N> a) {
       [](unsigned short x) { return nan(x); }, a);
 }
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <size_t N>
 sycl::marray<sycl::half, N> nan(sycl::marray<unsigned short, N> a) {
   return sycl_cts::math::run_func_on_marray<sycl::half, unsigned short, N>(
       [](unsigned short x) { return nan(x); }, a);
 }
-#endif
 
 sycl::half nextafter(sycl::half a, sycl::half b);
 sycl::half sinpi(sycl::half a);
 sycl::half tanpi(sycl::half a);
+#endif  // SYCL_CTS_ENABLE_HALF_TESTS
 
 sycl::half fast_dot(float p0);
 sycl::half fast_dot(sycl::float2 p0);
 sycl::half fast_dot(sycl::float3 p0);
 sycl::half fast_dot(sycl::float4 p0);
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 sycl::half fast_dot(sycl::mfloat2 p0);
 sycl::half fast_dot(sycl::mfloat3 p0);
 sycl::half fast_dot(sycl::mfloat4 p0);
-#endif
-
-#endif  // SYCL_CTS_ENABLE_HALF_TESTS
 
 #if SYCL_CTS_ENABLE_DOUBLE_TESTS
 
@@ -776,8 +766,6 @@ nan(sycl::vec<T, N> a) {
       [](T x) { return nan(x); }, a);
 }
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 template <typename T, size_t N>
 std::enable_if_t<std::is_same_v<unsigned long, T> ||
                      std::is_same_v<unsigned long long, T>,
@@ -786,7 +774,6 @@ nan(sycl::marray<T, N> a) {
   return sycl_cts::math::run_func_on_marray<double, T, N>(
       [](T x) { return nan(x); }, a);
 }
-#endif
 
 double sinpi(double a);
 double tanpi(double a);
@@ -794,11 +781,8 @@ double tanpi(double a);
 sycl::double4 cross(sycl::double4 p0, sycl::double4 p1);
 sycl::double3 cross(sycl::double3 p0, sycl::double3 p1);
 
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 sycl::mdouble4 cross(sycl::mdouble4 p0, sycl::mdouble4 p1);
 sycl::mdouble3 cross(sycl::mdouble3 p0, sycl::mdouble3 p1);
-#endif
 
 #endif  // SYCL_CTS_ENABLE_DOUBLE_TESTS
 
@@ -1238,10 +1222,6 @@ T dot(sycl::vec<T, N> a, sycl::vec<T, N> b) {
   return res;
 }
 
-// sycl::marray overloads of the above. Not supported by AdaptiveCpp.
-// Again, like for sycl::vec, these must be defined after all scalar overloads.
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 #define MAKE_MARRAY_VERSION(func)                       \
   template <typename T, size_t N>                       \
   sycl::marray<T, N> func(sycl::marray<T, N> a) {       \
@@ -1676,8 +1656,6 @@ T dot(sycl::marray<T, N> a, sycl::marray<T, N> b) {
   return res;
 }
 
-#endif  // SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-
 // Generic functions over both scalars and vec / marray types.
 // These need to be defined last.
 
@@ -1699,8 +1677,7 @@ sycl::vec<T, N> normalize(sycl::vec<T, N> a) {
   for (int i = 0; i < N; i++) res[i] = a[i] / len_a;
   return res;
 }
-// FIXME: AdaptiveCpp does not support marray
-#ifndef SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+
 template <typename T, size_t N>
 sycl::marray<T, N> normalize(sycl::marray<T, N> a) {
   sycl::marray<T, N> res;
@@ -1709,7 +1686,6 @@ sycl::marray<T, N> normalize(sycl::marray<T, N> a) {
   for (size_t i = 0; i < N; i++) res[i] = a[i] / len_a;
   return res;
 }
-#endif
 
 template <typename T>
 float fast_length(T p0) {