Merge pull request #1081 from AlexeySachkov/private/asachkov/simplify-enum-string-makers

bader · web-flow · commit 8872a8b9d97a · 2025-05-01T09:13:27.000-07:00
Use built-in Catch2 functionality for enums printing
diff --git a/tests/common/string_makers.h b/tests/common/string_makers.h
@@ -15,29 +15,6 @@
 #include <sycl/sycl.hpp>
 
 namespace Catch {
-template <>
-struct StringMaker<sycl::access_mode> {
-  using type = sycl::access_mode;
-  static std::string convert(type value) {
-    switch (value) {
-      case type::read:
-        return "access_mode::read";
-      case type::write:
-        return "access_mode::write";
-      case type::read_write:
-        return "access_mode::read_write";
-      case type::discard_write:
-        return "access_mode::discard_write (deprecated)";
-      case type::discard_read_write:
-        return "access_mode::discard_read_write (deprecated)";
-      case type::atomic:
-        return "access_mode::atomic (deprecated)";
-      default:
-        return "unknown access mode";
-    }
-  }
-};
-
 template <int Dimensions>
 struct StringMaker<sycl::id<Dimensions>> {
   static std::string convert(const sycl::id<Dimensions>& id) {
@@ -53,163 +30,6 @@ struct StringMaker<sycl::id<Dimensions>> {
     return ss.str();
   }
 };
-
-template <>
-struct StringMaker<sycl::target> {
-  using type = sycl::target;
-  static std::string convert(type value) {
-    switch (value) {
-      case type::device:
-        return "target::device";
-// FIXME: re-enable when target::host_task is implemented
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-      case type::host_task:
-        return "target::host_task";
-#endif
-
-      case type::constant_buffer:
-        return "target::constant_buffer (deprecated)";
-      case type::local:
-        return "target::local (deprecated)";
-      case type::host_buffer:
-        return "target::host_buffer (deprecated)";
-      default:
-        return "unknown target";
-    }
-  }
-};
-
-template <>
-struct StringMaker<sycl::aspect> {
-  using type = sycl::aspect;
-  static std::string convert(type value) {
-    switch (value) {
-      case type::cpu:
-        return "aspect::cpu";
-      case type::gpu:
-        return "aspect::gpu";
-      case type::accelerator:
-        return "aspect::accelerator";
-      case type::custom:
-        return "aspect::custom";
-      case type::emulated:
-        return "aspect::emulated";
-      case type::host_debuggable:
-        return "aspect::host_debuggable";
-      case type::fp16:
-        return "aspect::fp16";
-      case type::fp64:
-        return "aspect::fp64";
-      case type::atomic64:
-        return "aspect::atomic64";
-      case type::image:
-        return "aspect::image";
-      case type::online_compiler:
-        return "aspect::online_compiler";
-      case type::online_linker:
-        return "aspect::online_linker";
-      case type::queue_profiling:
-        return "aspect::queue_profiling";
-      case type::usm_device_allocations:
-        return "aspect::usm_device_allocations";
-      case type::usm_host_allocations:
-        return "aspect::usm_host_allocations";
-      case type::usm_atomic_host_allocations:
-        return "aspect::usm_atomic_host_allocations";
-      case type::usm_shared_allocations:
-        return "aspect::usm_shared_allocations";
-      case type::usm_atomic_shared_allocations:
-        return "aspect::usm_atomic_shared_allocations";
-      case type::usm_system_allocations:
-        return "aspect::usm_system_allocations";
-      default:
-        return "unknown aspect";
-    }
-  }
-};
-
-template <>
-struct StringMaker<sycl::memory_order> {
-  using type = sycl::memory_order;
-  static std::string convert(const type& order) {
-    switch (order) {
-      case type::relaxed:
-        return "memory_order::relaxed";
-      case type::acq_rel:
-        return "memory_order::acq_rel";
-      case type::seq_cst:
-        return "memory_order::seq_cst";
-      case type::acquire:
-        return "memory_order::acquire";
-      case type::release:
-        return "memory_order::release";
-      default:
-        return "unknown memory_order";
-    }
-  }
-};
-
-template <>
-struct StringMaker<sycl::memory_scope> {
-  using type = sycl::memory_scope;
-  static std::string convert(const type& scope) {
-    switch (scope) {
-      case type::work_item:
-        return "memory_scope::work_item";
-      case type::sub_group:
-        return "memory_scope::sub_group";
-      case type::work_group:
-        return "memory_scope::work_group";
-      case type::device:
-        return "memory_scope::device";
-      case type::system:
-        return "memory_scope::system";
-      default:
-        return "unknown memory_scope";
-    }
-  }
-};
-
-template <>
-struct StringMaker<sycl::access::address_space> {
-  using type = sycl::access::address_space;
-  static std::string convert(const type& addr_space) {
-    switch (addr_space) {
-      case type::global_space:
-        return "address_space::global_space";
-      case type::local_space:
-        return "address_space::local_space";
-      case type::generic_space:
-        return "address_space::generic_space";
-      case type::private_space:
-        return "address_space::private_space";
-      default:
-        // no stringification for deprecated ones
-        return "unknown or deprecated address_space";
-    }
-  }
-};
-
-// FIXME: re-enable when sycl::access::decorated is implemented in adaptivecpp
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-template <>
-struct StringMaker<sycl::access::decorated> {
-  using type = sycl::access::decorated;
-  static std::string convert(type value) {
-    switch (value) {
-      case type::yes:
-        return "access::decorated::yes";
-      case type::no:
-        return "access::decorated::no";
-      case type::legacy:
-        return "access::decorated::legacy";
-      default:
-        return "unknown";
-    }
-  }
-};
-#endif
-
 }  // namespace Catch
 
 #endif  // __SYCLCTS_TESTS_COMMON_STRING_MAKERS_H
diff --git a/util/sycl_enums.h b/util/sycl_enums.h
@@ -12,14 +12,6 @@
 #include <catch2/catch_tostring.hpp>
 #include <sycl/sycl.hpp>
 
-// TODO: Remove when all implementations support the sycl::errc enum
-#if SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
-#define SYCL_CTS_SUPPORT_HAS_ERRC_ENUM 0
-#else
-#define SYCL_CTS_SUPPORT_HAS_ERRC_ENUM 1
-#endif
-
-#if SYCL_CTS_SUPPORT_HAS_ERRC_ENUM == 1
 CATCH_REGISTER_ENUM(sycl::errc, sycl::errc::success, sycl::errc::runtime,
                     sycl::errc::kernel, sycl::errc::accessor,
                     sycl::errc::nd_range, sycl::errc::event,
@@ -29,6 +21,48 @@ CATCH_REGISTER_ENUM(sycl::errc, sycl::errc::success, sycl::errc::runtime,
                     sycl::errc::feature_not_supported,
                     sycl::errc::kernel_not_supported,
                     sycl::errc::backend_mismatch);
-#endif
+
+CATCH_REGISTER_ENUM(sycl::access::decorated, sycl::access::decorated::yes,
+                    sycl::access::decorated::no,
+                    sycl::access::decorated::legacy)
+
+CATCH_REGISTER_ENUM(sycl::access::address_space,
+                    sycl::access::address_space::global_space,
+                    sycl::access::address_space::local_space,
+                    sycl::access::address_space::generic_space,
+                    sycl::access::address_space::private_space)
+
+CATCH_REGISTER_ENUM(sycl::memory_scope, sycl::memory_scope::work_item,
+                    sycl::memory_scope::sub_group,
+                    sycl::memory_scope::work_group, sycl::memory_scope::device,
+                    sycl::memory_scope::system)
+
+CATCH_REGISTER_ENUM(sycl::memory_order, sycl::memory_order::relaxed,
+                    sycl::memory_order::acq_rel, sycl::memory_order::seq_cst,
+                    sycl::memory_order::acquire, sycl::memory_order::release)
+
+CATCH_REGISTER_ENUM(sycl::target, sycl::target::device,
+                    sycl::target::constant_buffer, sycl::target::local,
+                    sycl::target::host_buffer, sycl::target::host_task)
+
+CATCH_REGISTER_ENUM(sycl::access_mode, sycl::access_mode::read,
+                    sycl::access_mode::write, sycl::access_mode::read_write,
+                    sycl::access_mode::discard_write,
+                    sycl::access_mode::discard_read_write,
+                    sycl::access_mode::atomic)
+
+CATCH_REGISTER_ENUM(sycl::aspect, sycl::aspect::cpu, sycl::aspect::gpu,
+                    sycl::aspect::accelerator, sycl::aspect::custom,
+                    sycl::aspect::emulated, sycl::aspect::host_debuggable,
+                    sycl::aspect::fp16, sycl::aspect::fp64,
+                    sycl::aspect::atomic64, sycl::aspect::image,
+                    sycl::aspect::online_compiler, sycl::aspect::online_linker,
+                    sycl::aspect::queue_profiling,
+                    sycl::aspect::usm_device_allocations,
+                    sycl::aspect::usm_host_allocations,
+                    sycl::aspect::usm_atomic_host_allocations,
+                    sycl::aspect::usm_shared_allocations,
+                    sycl::aspect::usm_atomic_shared_allocations,
+                    sycl::aspect::usm_system_allocations)
 
 #endif  // __SYCLCTS_UTIL_SYCL_ENUMS_H
diff --git a/util/sycl_exceptions.cpp b/util/sycl_exceptions.cpp
@@ -58,14 +58,10 @@ std::string stringify_sycl_exception(const sycl::exception& e) {
   // Using reference to avoid object slicing
   const auto& code = e.code();
 
-#if SYCL_CTS_SUPPORT_HAS_ERRC_ENUM == 0
-  append_cstr("code", "errc enum not supported by implementation");
-#else
   using CodeStringMakerT = Catch::StringMaker<sycl::errc>;
   const auto& errc_value = static_cast<sycl::errc>(code.value());
 
   append_str("code", CodeStringMakerT::convert(errc_value));
-#endif //  SYCL_CTS_SUPPORT_HAS_ERRC_ENUM
 
   append_str("code raw value", std::to_string(code.value()));
   append_str("code message", code.message());
diff --git a/util/sycl_exceptions.h b/util/sycl_exceptions.h
@@ -95,7 +95,6 @@ class matcher_exception_category : public Catch::Matchers::MatcherGenericBase {
   const std::error_category& m_category;
 };
 
-#if SYCL_CTS_SUPPORT_HAS_ERRC_ENUM == 1
 /**
  *  Matcher for sycl::errc error codes
  *  C++ provides semantic match for std::error_code by operator==, still SYCL
@@ -132,7 +131,6 @@ struct matcher_equals_exception
  private:
   const sycl::errc& m_code_value;
 };
-#endif //  SYCL_CTS_SUPPORT_HAS_ERRC_ENUM
 
 }  // namespace detail
 
@@ -148,7 +146,6 @@ inline auto has_exception_category(const std::error_category& category) {
   return detail::matcher_exception_category(category);
 }
 
-#if SYCL_CTS_SUPPORT_HAS_ERRC_ENUM == 1
 /**
  *  Provides matcher for sycl::errc error codes with sycl_category check
  *
@@ -160,7 +157,6 @@ inline auto has_exception_category(const std::error_category& category) {
 inline auto equals_exception(const sycl::errc& code) {
   return detail::matcher_equals_exception(code);
 }
-#endif //  SYCL_CTS_SUPPORT_HAS_ERRC_ENUM == 1
 
 }  //  namespace sycl_cts::util
 
