[SYCL] update test to check void types

Author: dklochkov-emb

sycl/include/sycl/functional.hpp

@@ -23,31 +23,34 @@ template <typename T = void> using bit_xor = std::bit_xor<T>;
 
 // std:logical_and/std::logical_or with a non-void type returns bool,
 // sycl requires returning T.
-template <typename T = void> struct logical_and {
+template <typename T = void>
+struct logical_and
 #ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-  bool
-#else
-  T
+    : std::logical_and<T>
 #endif
-  operator()(const T &lhs, const T &rhs) const {
-    return lhs && rhs;
-  }
-};
+{
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
+  T operator()(const T &lhs, const T &rhs) const { return lhs && rhs; }
+#endif
+}; // namespace _V1
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 template <> struct logical_and<void> : std::logical_and<void> {};
+#endif
 
-template <typename T = void> struct logical_or {
+template <typename T = void>
+struct logical_or
 #ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-  bool
-#else
-  T
+    : std::logical_or<T>
 #endif
-  operator()(const T &lhs, const T &rhs) const {
-    return lhs || rhs;
-  }
-};
-
+{
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
+  T operator()(const T &lhs, const T &rhs) const { return lhs || rhs; }
+#endif
+}; // namespace sycl
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 template <> struct logical_or<void> : std::logical_or<void> {};
+#endif
 
 // sycl::minimum definition should be consistent with std::min
 template <typename T = void> struct minimum {

sycl/test/basic_tests/logical_operations.cpp

@@ -1,5 +1,7 @@
-// RUN: %clang -D__INTEL_PREVIEW_BREAKING_CHANGES -fsycl -o - %s
+// RUN: %clang -fpreview-breaking-changes -fsycl -o - %s
+// RUN: not %clang -fpreview-breaking-changes -fsycl -DTEST_VOID_TYPES -o - %s
 // RUN: %clang -fsycl -o - %s
+// RUN: not %clang -fsycl -DTEST_VOID_TYPES -o - %s
 
 #include <cassert>
 #include <sycl/functional.hpp>
@@ -14,6 +16,20 @@ int main() {
 #else
   static_assert(std::is_same_v<decltype(logicalAnd(1, 2)), int> == true);
   static_assert(std::is_same_v<decltype(logicalOr(1, 2)), int> == true);
+#endif
+  const auto logicalAndVoid = sycl::logical_and<void>();
+  const auto logicalOrVoid = sycl::logical_or<void>();
+
+  static_assert(std::is_same_v<decltype(logicalAndVoid(1, 2)), bool> == true);
+  static_assert(std::is_same_v<decltype(logicalOrVoid(1, 2)), bool> == true);
+
+#ifdef TEST_VOID_TYPES
+  static_assert(std::is_same_v<decltype(logicalAndVoid(static_cast<void>(1),
+                                                       static_cast<void>(2))),
+                               bool> == true);
+  static_assert(std::is_same_v<decltype(logicalOrVoid(static_cast<void>(1),
+                                                      static_cast<void>(2))),
+                               bool> == true);
 #endif
   return 0;
 }