Make the tests pass

NVIDIA · Feb 16, 2023 · 572f73d · 572f73d
1 parent d0a55c5
commit 572f73d
Show file tree

Hide file tree

Showing 18 changed files with 98 additions and 182 deletions.
diff --git a/.upstream-tests/test/cuda/memory_resource/get_property/forward_property.pass.cpp b/.upstream-tests/test/cuda/memory_resource/get_property/forward_property.pass.cpp
@@ -107,7 +107,7 @@ namespace forward_property {
       return convertible_to_upstream{};
     }
   };
-  static_assert(!cuda::has_property<derived_with_converstin_upstream_resource, prop_with_value>);
+  static_assert(!cuda::has_property<derived_with_converstin_upstream_resource, prop_with_value>, "");
 
   __host__ __device__ constexpr bool test_stateful() {
     using derived_no_override = derived_plain<upstream_with_stateful_property>;

diff --git a/.upstream-tests/test/cuda/memory_resource/get_property/has_property.pass.cpp b/.upstream-tests/test/cuda/memory_resource/get_property/has_property.pass.cpp
@@ -20,8 +20,8 @@ struct prop_with_value {
 };
 struct prop {};
 
-static_assert(cuda::property_with_value<prop_with_value>);
-static_assert(!cuda::property_with_value<prop>);
+static_assert(cuda::property_with_value<prop_with_value>, "");
+static_assert(!cuda::property_with_value<prop>, "");
 
 struct valid_property {
   friend void get_property(const valid_property&, prop) {}

diff --git a/...mory_resource/memory_resource.async_resource_ref/async_resource_ref.construction.pass.cpp b/...mory_resource/memory_resource.async_resource_ref/async_resource_ref.construction.pass.cpp
@@ -50,15 +50,12 @@ struct async_resource {
   int _val = 0;
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires !cuda::property_with_value<Property> &&
-   _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend void get_property(const async_resource&, Property) noexcept {}
+    (requires (!cuda::property_with_value<Property>) && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend void get_property(const async_resource&, Property) noexcept {}
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires cuda::property_with_value<Property>&&
-       _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend typename Property::value_type
-      get_property(const async_resource& res, Property) noexcept {
+    (requires cuda::property_with_value<Property> && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend typename Property::value_type get_property(const async_resource& res, Property) noexcept {
     return res._val;
   }
 };

diff --git a/...memory_resource/memory_resource.async_resource_ref/async_resource_ref.conversion.pass.cpp b/...memory_resource/memory_resource.async_resource_ref/async_resource_ref.conversion.pass.cpp
@@ -55,15 +55,12 @@ struct resource {
   int _val = 0;
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires !cuda::property_with_value<Property> &&
-   _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend void get_property(const resource&, Property) noexcept {}
+    (requires (!cuda::property_with_value<Property>) && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend void get_property(const resource&, Property) noexcept {}
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires cuda::property_with_value<Property>&&
-       _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend typename Property::value_type
-      get_property(const resource& res, Property) noexcept {
+    (requires cuda::property_with_value<Property> && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend typename Property::value_type get_property(const resource& res, Property) noexcept {
     return res._val;
   }
 };

diff --git a/...a/memory_resource/memory_resource.async_resource_ref/async_resource_ref.equality.fail.cpp b/...a/memory_resource/memory_resource.async_resource_ref/async_resource_ref.equality.fail.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: nvrtc
 
 // cuda::mr::async_resource_ref equality
 

diff --git a/...a/memory_resource/memory_resource.async_resource_ref/async_resource_ref.equality.pass.cpp b/...a/memory_resource/memory_resource.async_resource_ref/async_resource_ref.equality.pass.cpp
@@ -52,15 +52,12 @@ struct async_resource {
   int _val = 0;
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires !cuda::property_with_value<Property> &&
-   _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend void get_property(const async_resource&, Property) noexcept {}
+    (requires (!cuda::property_with_value<Property>) && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend void get_property(const async_resource&, Property) noexcept {}
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires cuda::property_with_value<Property>&&
-       _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend typename Property::value_type
-      get_property(const async_resource& res, Property) noexcept {
+    (requires cuda::property_with_value<Property> && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend typename Property::value_type get_property(const async_resource& res, Property) noexcept {
     return res._val;
   }
 };

diff --git a/...emory_resource/memory_resource.async_resource_ref/async_resource_ref.inheritance.pass.cpp b/...emory_resource/memory_resource.async_resource_ref/async_resource_ref.inheritance.pass.cpp
@@ -41,15 +41,12 @@ struct async_resource_base {
   bool operator!=(const async_resource_base& other) const { return false; }
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires !cuda::property_with_value<Property> &&
-   _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend void get_property(const async_resource_base&, Property) noexcept {}
+    (requires (!cuda::property_with_value<Property>) && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend void get_property(const async_resource_base&, Property) noexcept {}
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires cuda::property_with_value<Property>&&
-       _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend typename Property::value_type
-      get_property(const async_resource_base& res, Property) noexcept {
+    (requires cuda::property_with_value<Property> && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend typename Property::value_type get_property(const async_resource_base& res, Property) noexcept {
     return 42;
   }
 };
@@ -58,7 +55,6 @@ template <class... Properties>
 struct async_resource_derived_first
     : public async_resource_base<Properties...> {
   using super_t = async_resource_base<Properties...>;
-  using super_t::operator==;
 
   async_resource_derived_first(const int val) : _val(val) {}
 
@@ -73,9 +69,12 @@ struct async_resource_derived_first
   void deallocate_async(void* ptr, std::size_t, std::size_t,
                         cuda::stream_ref) override {}
 
+  bool operator==(const async_resource_derived_first& other) const { return true; }
+  bool operator!=(const async_resource_derived_first& other) const { return false; }
+
   int _val = 0;
 };
-static_assert(cuda::mr::async_resource<async_resource_derived_first<> >);
+static_assert(cuda::mr::async_resource<async_resource_derived_first<> >, "");
 
 struct some_data {
   int _val;
@@ -85,7 +84,6 @@ template <class... Properties>
 struct async_resource_derived_second
     : public async_resource_base<Properties...> {
   using super_t = async_resource_base<Properties...>;
-  using super_t::operator==;
 
   async_resource_derived_second(some_data* val) : _val(val) {}
 
@@ -100,6 +98,9 @@ struct async_resource_derived_second
   void deallocate_async(void* ptr, std::size_t, std::size_t,
                         cuda::stream_ref) override {}
 
+  bool operator==(const async_resource_derived_second& other) const { return true; }
+  bool operator!=(const async_resource_derived_second& other) const { return false; }
+
   some_data* _val = 0;
 };
 

diff --git a/...memory_resource/memory_resource.async_resource_ref/async_resource_ref.properties.pass.cpp b/...memory_resource/memory_resource.async_resource_ref/async_resource_ref.properties.pass.cpp
@@ -59,55 +59,52 @@ struct async_resource {
   int _val = 0;
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires !cuda::property_with_value<Property> &&
-   _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend void get_property(const async_resource&, Property) noexcept {}
+    (requires (!cuda::property_with_value<Property>) && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend void get_property(const async_resource&, Property) noexcept {}
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires cuda::property_with_value<Property>&&
-       _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend typename Property::value_type
-      get_property(const async_resource& res, Property) noexcept {
+    (requires cuda::property_with_value<Property> && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend typename Property::value_type get_property(const async_resource& res, Property) noexcept {
     return res._val;
   }
 };
 
 // Ensure we have the right size
 static_assert(sizeof(cuda::mr::async_resource_ref<property_with_value<short>,
                                                   property_with_value<int> >) ==
-              (4 * sizeof(void*)));
+              (4 * sizeof(void*)), "");
 static_assert(
     sizeof(cuda::mr::async_resource_ref<property_with_value<short>,
                                         property_without_value<int> >) ==
-    (3 * sizeof(void*)));
+    (3 * sizeof(void*)), "");
 static_assert(sizeof(cuda::mr::async_resource_ref<property_without_value<short>,
                                                   property_with_value<int> >) ==
-              (3 * sizeof(void*)));
+              (3 * sizeof(void*)), "");
 static_assert(
     sizeof(cuda::mr::async_resource_ref<property_without_value<short>,
                                         property_without_value<int> >) ==
-    (2 * sizeof(void*)));
+    (2 * sizeof(void*)), "");
 
 _LIBCUDACXX_TEMPLATE(class Property, class Ref)
-(requires !cuda::property_with_value<Property>) //
+  (requires (!cuda::property_with_value<Property>)) //
     int InvokeIfWithValue(const Ref& ref) {
   return -1;
 }
 
 _LIBCUDACXX_TEMPLATE(class Property, class Ref)
-(requires cuda::property_with_value<Property>) //
+  (requires cuda::property_with_value<Property>) //
     typename Property::value_type InvokeIfWithValue(const Ref& ref) {
   return get_property(ref, Property{});
 }
 
 _LIBCUDACXX_TEMPLATE(class Property, class Ref)
-(requires cuda::property_with_value<Property>) //
+  (requires cuda::property_with_value<Property>) //
     int InvokeIfWithoutValue(const Ref& ref) {
   return -1;
 }
 
 _LIBCUDACXX_TEMPLATE(class Property, class Ref)
-(requires !cuda::property_with_value<Property>) //
+  (requires (!cuda::property_with_value<Property>)) //
     int InvokeIfWithoutValue(const Ref& ref) {
   get_property(ref, Property{});
   return 1;
@@ -155,12 +152,12 @@ void test_property_forwarding() {
   using ref = cuda::mr::async_resource_ref<property_with_value<short> >;
 
   static_assert(cuda::mr::async_resource_with<res, property_with_value<short>,
-                                              property_with_value<int> >);
+                                              property_with_value<int> >, "");
   static_assert(!cuda::mr::async_resource_with<ref, property_with_value<short>,
-                                               property_with_value<int> >);
+                                               property_with_value<int> >, "");
 
   static_assert(
-      cuda::mr::async_resource_with<res, property_with_value<short> >);
+      cuda::mr::async_resource_with<res, property_with_value<short> >, "");
 }
 
 void test_async_resource_ref() {

diff --git a/...test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.construction.pass.cpp b/...test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.construction.pass.cpp
@@ -40,15 +40,12 @@ struct resource {
   int _val = 0;
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires !cuda::property_with_value<Property> &&
-   _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend void get_property(const resource&, Property) noexcept {}
+    (requires (!cuda::property_with_value<Property>) && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend void get_property(const resource&, Property) noexcept {}
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires cuda::property_with_value<Property>&&
-       _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend typename Property::value_type
-      get_property(const resource& res, Property) noexcept {
+    (requires cuda::property_with_value<Property> && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend typename Property::value_type get_property(const resource& res, Property) noexcept {
     return res._val;
   }
 };

diff --git a/...s/test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.conversion.pass.cpp b/...s/test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.conversion.pass.cpp
@@ -55,15 +55,12 @@ struct resource {
   int _val = 0;
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires !cuda::property_with_value<Property> &&
-   _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend void get_property(const resource&, Property) noexcept {}
+    (requires (!cuda::property_with_value<Property>) && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend void get_property(const resource&, Property) noexcept {}
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires cuda::property_with_value<Property>&&
-       _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend typename Property::value_type
-      get_property(const resource& res, Property) noexcept {
+    (requires cuda::property_with_value<Property> && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend typename Property::value_type get_property(const resource& res, Property) noexcept {
     return res._val;
   }
 };

diff --git a/...sts/test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.equality.fail.cpp b/...sts/test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.equality.fail.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: nvrtc
 
 // cuda::mr::resource_ref equality
 

diff --git a/...sts/test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.equality.pass.cpp b/...sts/test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.equality.pass.cpp
@@ -41,15 +41,12 @@ struct resource {
   int _val = 0;
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires !cuda::property_with_value<Property> &&
-   _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend void get_property(const resource&, Property) noexcept {}
+    (requires (!cuda::property_with_value<Property>) && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend void get_property(const resource&, Property) noexcept {}
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires cuda::property_with_value<Property>&&
-       _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend typename Property::value_type
-      get_property(const resource& res, Property) noexcept {
+    (requires cuda::property_with_value<Property> && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend typename Property::value_type get_property(const resource& res, Property) noexcept {
     return res._val;
   }
 };

diff --git a/.../test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.inheritance.pass.cpp b/.../test/cuda/memory_resource/memory_resource.resource_ref/resource_ref.inheritance.pass.cpp
@@ -36,33 +36,32 @@ struct resource_base {
   bool operator!=(const resource_base& other) const { return false; }
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires !cuda::property_with_value<Property> &&
-   _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend void get_property(const resource_base&, Property) noexcept {}
+    (requires (!cuda::property_with_value<Property>) && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend void get_property(const resource_base&, Property) noexcept {}
 
   _LIBCUDACXX_TEMPLATE(class Property)
-  (requires cuda::property_with_value<Property>&&
-       _CUDA_VSTD::_One_of<Property, Properties...>) //
-      friend typename Property::value_type
-      get_property(const resource_base& res, Property) noexcept {
+    (requires cuda::property_with_value<Property> && _CUDA_VSTD::_One_of<Property, Properties...>) //
+  friend typename Property::value_type get_property(const resource_base& res, Property) noexcept {
     return 42;
   }
 };
 
 template <class... Properties>
 struct resource_derived_first : public resource_base<Properties...> {
   using super_t = resource_base<Properties...>;
-  using super_t::operator==;
 
   resource_derived_first(const int val) : _val(val) {}
 
   void* allocate(std::size_t, std::size_t) override { return &_val; }
 
   void deallocate(void* ptr, std::size_t, std::size_t) override {}
 
+  bool operator==(const resource_derived_first& other) const { return true; }
+  bool operator!=(const resource_derived_first& other) const { return false; }
+
   int _val = 0;
 };
-static_assert(cuda::mr::resource<resource_derived_first<> >);
+static_assert(cuda::mr::resource<resource_derived_first<> >, "");
 
 struct some_data {
   int _val;
@@ -71,14 +70,16 @@ struct some_data {
 template <class... Properties>
 struct resource_derived_second : public resource_base<Properties...> {
   using super_t = resource_base<Properties...>;
-  using super_t::operator==;
 
   resource_derived_second(some_data* val) : _val(val) {}
 
   void* allocate(std::size_t, std::size_t) override { return &_val->_val; }
 
   void deallocate(void* ptr, std::size_t, std::size_t) override {}
 
+  bool operator==(const resource_derived_second& other) const { return true; }
+  bool operator!=(const resource_derived_second& other) const { return false; }
+
   some_data* _val = 0;
 };