diff --git a/tests/accessor/generic_accessor_api_common.h b/tests/accessor/generic_accessor_api_common.h
index 1c6abe969..ed563c598 100644
--- a/tests/accessor/generic_accessor_api_common.h
+++ b/tests/accessor/generic_accessor_api_common.h
@@ -58,9 +58,29 @@ void test_accessor_methods(const AccT &accessor,
 #endif
 }
 
+template <typename Accessor>
+extern const sycl::target accessor_target_v;
+
+template <typename T, int Dims, sycl::access_mode Mode, sycl::target Target,
+          sycl::access::placeholder IsPlaceholder>
+inline constexpr sycl::target
+    accessor_target_v<sycl::accessor<T, Dims, Mode, Target, IsPlaceholder>> =
+        Target;
+
+template <typename T, int Dims>
+inline constexpr sycl::target accessor_target_v<sycl::local_accessor<T, Dims>> =
+    sycl::target::device;
+
+template <typename T, int Dims, sycl::access_mode Mode>
+inline constexpr sycl::target
+    accessor_target_v<sycl::host_accessor<T, Dims, Mode>> =
+        sycl::target::host_buffer;
+
 template <typename T, typename AccT>
 void test_accessor_ptr_host(AccT &accessor, T expected_data) {
-  {
+  // get_multi_ptr is only defined for device accessors and local accessors
+  if constexpr (accessor_target_v<std::remove_cv_t<AccT>> ==
+                sycl::target::device) {
     INFO("check get_multi_ptr() method");
     auto acc_multi_ptr_no =
         accessor.template get_multi_ptr<sycl::access::decorated::no>();
diff --git a/tests/accessor_legacy/accessor_api_buffer_common.h b/tests/accessor_legacy/accessor_api_buffer_common.h
index 878fad825..422d377e0 100644
--- a/tests/accessor_legacy/accessor_api_buffer_common.h
+++ b/tests/accessor_legacy/accessor_api_buffer_common.h
@@ -108,7 +108,10 @@ class check_buffer_accessor_api_methods {
             "accessor does not properly report placeholder status");
       }
     }
-    {
+    // legacy accessors do not have the size() member function
+    if constexpr (target != sycl::access::target::constant_buffer &&
+                  target != sycl::access::target::local &&
+                  target != sycl::access::target::host_buffer) {
       /** check size() method
        */
       auto accessorCount = accessor.size();
diff --git a/tests/accessor_legacy/accessor_api_local_common.h b/tests/accessor_legacy/accessor_api_local_common.h
index 9f7e00b5b..bd4bf52f7 100644
--- a/tests/accessor_legacy/accessor_api_local_common.h
+++ b/tests/accessor_legacy/accessor_api_local_common.h
@@ -67,19 +67,8 @@ class check_local_accessor_api_methods {
           util::get_cts_object::range<data_dim<dims>::value>::get(1, 1, 1);
       error_buffer_t errorBuffer(errors.get(), sycl::range<1>(2));
 
-      queue.submit([&](sycl::handler &h) {
+      queue.submit([&](sycl::handler& h) {
         auto acc = make_local_accessor_generic<T, dims, mode>(range, h);
-        {
-          /** check size() method
-          */
-          auto accessorCount = acc.size();
-          check_return_type<size_t>(log, accessorCount, "size()");
-          const auto expectedCount = ((dims == 0) ? 1 : count);
-          if (accessorCount != expectedCount) {
-            fail_for_accessor<T, dims, mode, target>(log, typeName,
-                "accessor does not return the correct count");
-          }
-        }
         {
           /** check get_count() method
            */
diff --git a/tests/atomic_ref/atomic_ref_common.h b/tests/atomic_ref/atomic_ref_common.h
index fd296e88e..98475ef12 100644
--- a/tests/atomic_ref/atomic_ref_common.h
+++ b/tests/atomic_ref/atomic_ref_common.h
@@ -253,7 +253,8 @@ inline bool memory_order_is_supported(sycl::queue& q,
   return it != memory_orders_supported.end();
 }
 
-inline bool memory_scope_is_suppoted(sycl::queue& q, sycl::memory_scope scope) {
+inline bool memory_scope_is_supported(sycl::queue& q,
+                                      sycl::memory_scope scope) {
   std::vector<sycl::memory_scope> memory_scopes_supported =
       q.get_device()
           .get_info<sycl::info::device::atomic_memory_scope_capabilities>();
@@ -266,7 +267,7 @@ inline bool memory_order_and_scope_are_supported(sycl::queue& q,
                                                  sycl::memory_order order,
                                                  sycl::memory_scope scope) {
   return memory_order_is_supported(q, order) &&
-         memory_scope_is_suppoted(q, scope);
+         memory_scope_is_supported(q, scope);
 }
 
 inline bool memory_order_and_scope_are_not_supported(sycl::queue& q,
diff --git a/tests/atomic_ref_stress/atomic_ref_stress_common.h b/tests/atomic_ref_stress/atomic_ref_stress_common.h
index f927d02ae..a5601f945 100644
--- a/tests/atomic_ref_stress/atomic_ref_stress_common.h
+++ b/tests/atomic_ref_stress/atomic_ref_stress_common.h
@@ -172,7 +172,7 @@ class aquire_release {
           refA.store(0);
           refB.store(0);
           sycl::group_barrier(item.get_group());
-          if (item.get_local_id() == 0) {
+          if (item.get_local_id() == sycl::id(0)) {
             x = refA.load();
             refB.store(1);
           } else {
@@ -180,7 +180,7 @@ class aquire_release {
             refA.store(1);
           }
           sycl::group_barrier(item.get_group());
-          if (item.get_local_id() == 0)
+          if (item.get_local_id() == sycl::id(0))
             res_acc[item.get_group_linear_id()] = !(x == 1 && y == 1);
         });
       });
diff --git a/tests/device/device_info.cpp b/tests/device/device_info.cpp
index b4000191d..9f3853d7b 100644
--- a/tests/device/device_info.cpp
+++ b/tests/device/device_info.cpp
@@ -146,7 +146,6 @@ TEST_CASE("device info", "[device]") {
     check_get_info_param<sycl::info::device::image3d_max_depth, size_t>(dev);
     check_get_info_param<sycl::info::device::image_max_buffer_size, size_t>(
         dev);
-    check_get_info_param<sycl::info::device::image_max_array_size, size_t>(dev);
     check_get_info_param<sycl::info::device::max_samplers, uint32_t>(dev);
     check_get_info_param<sycl::info::device::max_parameter_size, size_t>(dev);
     check_get_info_param<sycl::info::device::mem_base_addr_align, uint32_t>(
@@ -223,8 +222,6 @@ TEST_CASE("device info", "[device]") {
     check_get_info_param<sycl::info::device::driver_version, std::string>(dev);
     check_get_info_param<sycl::info::device::profile, std::string>(dev);
     check_get_info_param<sycl::info::device::version, std::string>(dev);
-    check_get_info_param<sycl::info::device::opencl_c_version, std::string>(
-        dev);
     check_get_info_param<sycl::info::device::backend_version, std::string>(dev);
 
     check_get_info_param<sycl::info::device::aspects,
diff --git a/tests/device_selector/device_selector_predefined.cpp b/tests/device_selector/device_selector_predefined.cpp
index cd50e51ad..78f825ee3 100644
--- a/tests/device_selector/device_selector_predefined.cpp
+++ b/tests/device_selector/device_selector_predefined.cpp
@@ -74,8 +74,8 @@ TEST_CASE("predefined selectors", "[device_selector]") {
       try {
         auto cpuDevice = util::get_cts_object::device(cpuSelector);
         FAIL("selected a CPU device when none are available");
-      } catch (const sycl::runtime_error &e) {
-        // sycl::runtime_error is expected
+      } catch (const sycl::exception& e) {
+        // sycl::exception is expected
       } catch (...) {
         FAIL("wrong error thrown when no CPU devices are available");
       }
@@ -90,8 +90,8 @@ TEST_CASE("predefined selectors", "[device_selector]") {
       try {
         auto gpuDevice = util::get_cts_object::device(gpuSelector);
         FAIL("selected a GPU device when none are available");
-      } catch (const sycl::runtime_error &e) {
-        // sycl::runtime_error is expected
+      } catch (const sycl::exception& e) {
+        // sycl::exception is expected
       } catch (...) {
         FAIL("wrong error thrown when no GPU devices are available");
       }
@@ -108,8 +108,8 @@ TEST_CASE("predefined selectors", "[device_selector]") {
         auto acceleratorDevice =
             util::get_cts_object::device(acceleratorSelector);
         FAIL("selected an accelerator device when none are available");
-      } catch (const sycl::runtime_error &e) {
-        // sycl::runtime_error is expected
+      } catch (const sycl::exception& e) {
+        // sycl::exception is expected
       } catch (...) {
         FAIL("wrong error thrown when no accelerator devices are available");
       }
diff --git a/tests/exceptions/exceptions_constructors.cpp b/tests/exceptions/exceptions_constructors.cpp
index 04a187bd4..e4691697d 100644
--- a/tests/exceptions/exceptions_constructors.cpp
+++ b/tests/exceptions/exceptions_constructors.cpp
@@ -194,8 +194,14 @@ TEST_CASE("Constructors for sycl::exception with sycl::errc error codes",
       check_exception(copy, errcode, sycl::sycl_category());
     }
     SECTION("operator=(const exception& other)") {
+      // sycl::exception is not default-constructible, so explicitly construct
+      // `copy` with an error code that is different from `errcode`
+      std::error_code other_errc(errcode == sycl::errc::success
+                                     ? sycl::errc::runtime
+                                     : sycl::errc::success);
+
       sycl::exception e(std_errc);
-      sycl::exception copy;
+      sycl::exception copy(other_errc);
       CHECK_NOTHROW((copy = e));
       check_exception(copy, errcode, sycl::sycl_category());
     }
diff --git a/tests/id/id.cpp b/tests/id/id.cpp
index 5e6a573ba..13a46adf9 100644
--- a/tests/id/id.cpp
+++ b/tests/id/id.cpp
@@ -239,7 +239,8 @@ TEMPLATE_TEST_CASE_SIG("id can be implicitly conversion-constructed from item",
   q.submit([r, &result_buf](sycl::handler& cgh) {
      sycl::accessor result{result_buf, cgh, sycl::write_only};
      cgh.parallel_for<kernel_id<D>>(r, [=](sycl::item<D> itm) {
-       if (itm.get_id() == id<D>{r} - 1) {
+       // `ul` suffix is necessary to resolve ambiguity for id<1>
+       if (itm.get_id() == id<D>{r} - 1ul) {
          // Use assignment operator to trigger implicit conversion
          result[0] = itm;
        }
diff --git a/tests/kernel/kernel_semantics.cpp b/tests/kernel/kernel_semantics.cpp
index 5f3bac7fc..31428198d 100644
--- a/tests/kernel/kernel_semantics.cpp
+++ b/tests/kernel/kernel_semantics.cpp
@@ -44,10 +44,10 @@ TEST_CASE("kernel common reference semantics", "[kernel]") {
 
   sycl::kernel kernel_0 =
       sycl::get_kernel_bundle<sycl::bundle_state::executable>(context_0)
-          .template get_kernel(sycl::get_kernel_id<k_name>());
+          .get_kernel(sycl::get_kernel_id<k_name>());
   sycl::kernel kernel_1 =
       sycl::get_kernel_bundle<sycl::bundle_state::executable>(context_1)
-          .template get_kernel(sycl::get_kernel_id<k_name_other>());
+          .get_kernel(sycl::get_kernel_id<k_name_other>());
   common_reference_semantics::check_host<storage>(kernel_0, kernel_1, "kernel");
   sycl_cts::tests::kernel_bundle::define_kernel<k_name>(queue_0);
   sycl_cts::tests::kernel_bundle::define_kernel<k_name_other>(queue_1);
diff --git a/tests/marray/marray_operators.h b/tests/marray/marray_operators.h
index f18fa6edf..1885a28f3 100644
--- a/tests/marray/marray_operators.h
+++ b/tests/marray/marray_operators.h
@@ -822,11 +822,18 @@ class check_marray_pre_unary_operators_for_type {
     INFO("prefix unary operators for type \"" << type_name << "\": ");
 
     const auto num_elements = marray_common::get_num_elements();
-
-    static const auto unary_operators =
-        named_type_pack<op_upos, op_uneg, op_pre_inc, op_pre_dec, op_lnot,
-                        op_bnot>::generate("unary +", "unary -", "pre ++",
-                                           "pre --", "!", "~");
+    static const auto unary_operators = [] {
+      if constexpr (std::is_same_v<DataT, bool>) {
+        // marray<bool> does not have operator++/--
+        return named_type_pack<op_upos, op_uneg, op_lnot, op_bnot>::generate(
+            "unary +", "unary -", "!", "~");
+      } else {
+        return named_type_pack<op_upos, op_uneg, op_pre_inc, op_pre_dec,
+                               op_lnot, op_bnot>::generate("unary +", "unary -",
+                                                           "pre ++", "pre --",
+                                                           "!", "~");
+      }
+    }();
     for_all_combinations<run_unary, DataT>(num_elements, unary_operators);
   }
 };
@@ -839,11 +846,14 @@ class check_marray_post_unary_operators_for_type {
 
     const auto num_elements = marray_common::get_num_elements();
 
-    static const auto unary_post_operators =
-        named_type_pack<op_post_inc, op_post_dec>::generate("post ++",
-                                                            "post --");
-    for_all_combinations<run_unary_post, DataT>(num_elements,
-                                                unary_post_operators);
+    // marray<bool> does not have operator++/--
+    if constexpr (!std::is_same_v<DataT, bool>) {
+      static const auto unary_post_operators =
+          named_type_pack<op_post_inc, op_post_dec>::generate("post ++",
+                                                              "post --");
+      for_all_combinations<run_unary_post, DataT>(num_elements,
+                                                  unary_post_operators);
+    }
   }
 };
 
diff --git a/tests/namespace/namespace.cpp.in b/tests/namespace/namespace.cpp.in
index 72a9840d4..75cbcbd79 100644
--- a/tests/namespace/namespace.cpp.in
+++ b/tests/namespace/namespace.cpp.in
@@ -29,9 +29,14 @@
 
 #include <iostream>
 
-struct kernel_1;
-struct kernel_2;
-struct kernel_3;
+// Multiple translation units are instantiated from this .in file and linked together, so we must
+// ensure that kernel names are namespaced to disambiguate their definitions
+namespace kernels CTS_NAMESPACE {
+  struct kernel_1;
+  struct kernel_2;
+  struct kernel_3;
+}
+using namespace kernels CTS_NAMESPACE;
 
 /** Example program, adapted to use the CTS queue. */
 static int test_namespace() {
diff --git a/tests/scalars/CMakeLists.txt b/tests/scalars/CMakeLists.txt
index c24e4e87e..c8b65be26 100644
--- a/tests/scalars/CMakeLists.txt
+++ b/tests/scalars/CMakeLists.txt
@@ -2,7 +2,7 @@
 file(GLOB test_cases_list *.cpp)
 
 if(NOT SYCL_CTS_ENABLE_OPENCL_INTEROP_TESTS)
-  list(FILTER test_cases_list EXCLUDE REGEX scalars_interopability_types.cpp)
+  list(FILTER test_cases_list EXCLUDE REGEX scalars_interoperability_types.cpp)
 endif()
 
 add_cts_test(${test_cases_list})
diff --git a/tests/scalars/scalars_fixed_width_types.cpp b/tests/scalars/scalars_fixed_width_types.cpp
index 738bf8f2a..8bcb435fd 100644
--- a/tests/scalars/scalars_fixed_width_types.cpp
+++ b/tests/scalars/scalars_fixed_width_types.cpp
@@ -49,7 +49,8 @@ TEST_CASE("Fixed width types size equality", "[scalars]") {
     CHECK(results[i]);
   }
 
-  std::iota(results.begin(), results.end(), false);
+  std::fill(results.begin(), results.end(), false);
+
   {
     sycl::buffer<bool, 1> res_buf(results.data(), {types_count});
     queue.submit([&](sycl::handler& cgh) {
diff --git a/tests/vector_load_store/generate_vector_load_store.py b/tests/vector_load_store/generate_vector_load_store.py
index dad739261..411a8571b 100755
--- a/tests/vector_load_store/generate_vector_load_store.py
+++ b/tests/vector_load_store/generate_vector_load_store.py
@@ -54,25 +54,19 @@
 
             cgh.single_task<class ${kernelName}>([=]() {
               auto testVec${type_as_str}${size} = sycl::vec<${type}, ${size}>(${val});
-              testVec${type_as_str}${size}.load(0, inPtr${type_as_str}${size});
-              testVec${type_as_str}${size}.store(0, outPtr${type_as_str}${size});
 
               auto multiPtrIn${type_as_str}${size} = inPtr${type_as_str}${size}.get_multi_ptr<${decorated}>();
               sycl::global_ptr<const ${type}> constMultiPtrIn${type_as_str}${size} = multiPtrIn${type_as_str}${size};
               auto multiPtrOut${type_as_str}${size} = outPtr${type_as_str}${size}.get_multi_ptr<${decorated}>();
-              testVec${type_as_str}${size}.load(0, multiPtrIn${type_as_str}${size});
               testVec${type_as_str}${size}.load(0, constMultiPtrIn${type_as_str}${size});
               testVec${type_as_str}${size}.store(0, multiPtrOut${type_as_str}${size});
 
               auto cleanVec${type_as_str}${size} = sycl::vec<${type}, ${size}>(${val});
               sycl::vec<${type}, ${size}> swizzledVec {cleanVec${type_as_str}${size}.template swizzle<${swizVals}>()};
-              swizzledVec.load(0, swizzleInPtr${type_as_str}${size});
-              swizzledVec.store(0, swizzleOutPtr${type_as_str}${size});
 
               auto multiPtrInSwizzle${type_as_str}${size} = swizzleInPtr${type_as_str}${size}.get_multi_ptr<${decorated}>();
               sycl::global_ptr<const ${type}> constMultiPtrInSwizzle${type_as_str}${size} = multiPtrInSwizzle${type_as_str}${size};
               auto multiPtrOutSwizzle${type_as_str}${size} = swizzleOutPtr${type_as_str}${size}.get_multi_ptr<${decorated}>();
-              swizzledVec.load(0, multiPtrInSwizzle${type_as_str}${size});
               swizzledVec.load(0, constMultiPtrInSwizzle${type_as_str}${size});
               swizzledVec.store(0, multiPtrOutSwizzle${type_as_str}${size});
             });
diff --git a/tests/vector_operators/generate_vector_operators.py b/tests/vector_operators/generate_vector_operators.py
index e7de5c4ee..c6de167f1 100755
--- a/tests/vector_operators/generate_vector_operators.py
+++ b/tests/vector_operators/generate_vector_operators.py
@@ -207,92 +207,93 @@
   }
 
   // Post and pre increment and decrement
-  // C++17 does not allow ++ or -- (either prefix or postfix) for the bool type
-  // So skip tests for these operators if DataT is bool
-  if constexpr (!std::is_same_v<${type}, bool>) {
-    for (int i = 0; i < ${size}; ++i) {
-      resArr[i] = static_cast<${type}>(${test_value_1});
-    }
-    for (int i = 0; i < ${size}; ++i) {
-      resArr2[i] = static_cast<${type}>(${test_value_1}) + static_cast<${type}>(1);
-    }
-    testVec1Copy = testVec1;
-    resVec = testVec1Copy++;
-    if (!check_vector_values(resVec, resArr)) {
-      resAcc[0] = false;
-    }
-    if (!check_vector_values(testVec1Copy, resArr2)) {
-      resAcc[0] = false;
-    }
-    testVec1Copy = testVec1;
-    resVec = testVec1Copy.${swizzle}++;
-    if (!check_vector_values(resVec, resArr)) {
-      resAcc[0] = false;
-    }
-    if (!check_vector_values(testVec1Copy, resArr2)) {
-      resAcc[0] = false;
-    }
-    for (int i = 0; i < ${size}; ++i) {
-      resArr[i] = static_cast<${type}>(${test_value_1}) + static_cast<${type}>(1);
-    }
-    testVec1Copy = testVec1;
-    resVec = ++testVec1Copy;
-    if (!check_vector_values(resVec, resArr)) {
-      resAcc[0] = false;
-    }
-    if (!check_vector_values(testVec1Copy, resArr)) {
-      resAcc[0] = false;
-    }
-    testVec1Copy = testVec1;
-    resVec = ++testVec1Copy.${swizzle};
-    if (!check_vector_values(resVec, resArr)) {
-      resAcc[0] = false;
-    }
-    if (!check_vector_values(testVec1Copy, resArr)) {
-      resAcc[0] = false;
-    }
-    for (int i = 0; i < ${size}; ++i) {
-      resArr[i] = static_cast<${type}>(${test_value_1});
-    }
-    for (int i = 0; i < ${size}; ++i) {
-      resArr2[i] = static_cast<${type}>(${test_value_1}) - static_cast<${type}>(1);
-    }
-    testVec1Copy = testVec1;
-    resVec = testVec1Copy--;
-    if (!check_vector_values(resVec, resArr)) {
-      resAcc[0] = false;
-    }
-    if (!check_vector_values(testVec1Copy, resArr2)) {
-      resAcc[0] = false;
-    }
-    testVec1Copy = testVec1;
-    resVec = testVec1Copy.${swizzle}--;
-    if (!check_vector_values(resVec, resArr)) {
-      resAcc[0] = false;
-    }
-    if (!check_vector_values(testVec1Copy, resArr2)) {
-      resAcc[0] = false;
-    }
-    for (int i = 0; i < ${size}; ++i) {
-      resArr[i] = static_cast<${type}>(${test_value_1}) - static_cast<${type}>(1);
-    }
-    testVec1Copy = testVec1;
-    resVec = --testVec1Copy;
-    if (!check_vector_values(resVec, resArr)) {
-      resAcc[0] = false;
-    }
-    if (!check_vector_values(testVec1Copy, resArr)) {
-      resAcc[0] = false;
-    }
-    testVec1Copy = testVec1;
-    resVec = --testVec1Copy.${swizzle};
-    if (!check_vector_values(resVec, resArr)) {
-      resAcc[0] = false;
-    }
-    if (!check_vector_values(testVec1Copy, resArr)) {
-      resAcc[0] = false;
-    }
+  // The standard does not require ++ and -- (either prefix or postfix) for the
+  // bool type, so we skip tests for these operators if DataT is bool. This cannot
+  // be done via `if constexpr` because the type is not a dependent type.
+#if !${type_is_bool}
+  for (int i = 0; i < ${size}; ++i) {
+    resArr[i] = static_cast<${type}>(${test_value_1});
+  }
+  for (int i = 0; i < ${size}; ++i) {
+    resArr2[i] = static_cast<${type}>(${test_value_1}) + static_cast<${type}>(1);
+  }
+  testVec1Copy = testVec1;
+  resVec = testVec1Copy++;
+  if (!check_vector_values(resVec, resArr)) {
+    resAcc[0] = false;
+  }
+  if (!check_vector_values(testVec1Copy, resArr2)) {
+    resAcc[0] = false;
+  }
+  testVec1Copy = testVec1;
+  resVec = testVec1Copy.${swizzle}++;
+  if (!check_vector_values(resVec, resArr)) {
+    resAcc[0] = false;
+  }
+  if (!check_vector_values(testVec1Copy, resArr2)) {
+    resAcc[0] = false;
+  }
+  for (int i = 0; i < ${size}; ++i) {
+    resArr[i] = static_cast<${type}>(${test_value_1}) + static_cast<${type}>(1);
+  }
+  testVec1Copy = testVec1;
+  resVec = ++testVec1Copy;
+  if (!check_vector_values(resVec, resArr)) {
+    resAcc[0] = false;
+  }
+  if (!check_vector_values(testVec1Copy, resArr)) {
+    resAcc[0] = false;
+  }
+  testVec1Copy = testVec1;
+  resVec = ++testVec1Copy.${swizzle};
+  if (!check_vector_values(resVec, resArr)) {
+    resAcc[0] = false;
+  }
+  if (!check_vector_values(testVec1Copy, resArr)) {
+    resAcc[0] = false;
+  }
+  for (int i = 0; i < ${size}; ++i) {
+    resArr[i] = static_cast<${type}>(${test_value_1});
+  }
+  for (int i = 0; i < ${size}; ++i) {
+    resArr2[i] = static_cast<${type}>(${test_value_1}) - static_cast<${type}>(1);
+  }
+  testVec1Copy = testVec1;
+  resVec = testVec1Copy--;
+  if (!check_vector_values(resVec, resArr)) {
+    resAcc[0] = false;
+  }
+  if (!check_vector_values(testVec1Copy, resArr2)) {
+    resAcc[0] = false;
+  }
+  testVec1Copy = testVec1;
+  resVec = testVec1Copy.${swizzle}--;
+  if (!check_vector_values(resVec, resArr)) {
+    resAcc[0] = false;
+  }
+  if (!check_vector_values(testVec1Copy, resArr2)) {
+    resAcc[0] = false;
+  }
+  for (int i = 0; i < ${size}; ++i) {
+    resArr[i] = static_cast<${type}>(${test_value_1}) - static_cast<${type}>(1);
+  }
+  testVec1Copy = testVec1;
+  resVec = --testVec1Copy;
+  if (!check_vector_values(resVec, resArr)) {
+    resAcc[0] = false;
+  }
+  if (!check_vector_values(testVec1Copy, resArr)) {
+    resAcc[0] = false;
+  }
+  testVec1Copy = testVec1;
+  resVec = --testVec1Copy.${swizzle};
+  if (!check_vector_values(resVec, resArr)) {
+    resAcc[0] = false;
+  }
+  if (!check_vector_values(testVec1Copy, resArr)) {
+    resAcc[0] = false;
   }
+#endif
 
   // Assignment operators
   for (int i = 0; i < ${size}; ++i) {
@@ -1338,6 +1339,7 @@ def generate_all_type_test(type_str, size):
         val=Data.value_default_dict[type_str])
     test_string += all_type_test_template.substitute(
         type=type_str,
+        type_is_bool=int(type_str == 'bool'),
         size=str(size),
         swizzle=get_swizzle(size),
         test_value_1=1,
diff --git a/util/device_set.cpp b/util/device_set.cpp
index 3c6fcf23c..f6806d15e 100644
--- a/util/device_set.cpp
+++ b/util/device_set.cpp
@@ -48,7 +48,9 @@ void device_set::intersect(const device_set& other) {
     const auto& device = *it;
     return other.m_devices.find(device) == other.m_devices.end();
   };
-  erase_if(m_devices, condition);
+  // must explicitly specify namespace `util` to avoid ambiguity with
+  // std::erase_if when compiling for C++20
+  util::erase_if(m_devices, condition);
 }
 
 void device_set::removeDevsWith(sycl::aspect aspect) {
@@ -56,7 +58,7 @@ void device_set::removeDevsWith(sycl::aspect aspect) {
     const auto& device = *it;
     return device.has(aspect);
   };
-  erase_if(m_devices, condition);
+  util::erase_if(m_devices, condition);
 }
 
 void device_set::removeDevsWith(std::initializer_list<sycl::aspect> aspects) {
@@ -70,7 +72,7 @@ void device_set::removeDevsWithout(sycl::aspect aspect) {
     const auto& device = *it;
     return !device.has(aspect);
   };
-  erase_if(m_devices, condition);
+  util::erase_if(m_devices, condition);
 }
 
 void device_set::removeDevsWithout(const kernel_restrictions& restriction) {
@@ -78,7 +80,7 @@ void device_set::removeDevsWithout(const kernel_restrictions& restriction) {
     const auto& device = *it;
     return !restriction.is_compatible(device);
   };
-  erase_if(m_devices, condition);
+  util::erase_if(m_devices, condition);
 }
 
 device_set device_set::filtered(const device_set& other, sycl::aspect aspect) {