Update freestanding tests

Author: 20162026

tests/beman/inplace_vector/freestanding.test.cpp

@@ -3,178 +3,137 @@
 #include <gtest/gtest.h>
 
 // constexpr void assign(InputIterator first, InputIterator last);
-template <typename, typename = std::void_t<>>
-struct has_assign_iterator : std::false_type {};
 template <typename T>
-struct has_assign_iterator<T, std::void_t<decltype(std::declval<T>().assign(
-                                  std::declval<typename T::iterator>(),
-                                  std::declval<typename T::iterator>()))>>
-    : std::true_type {};
+concept has_assign_iterator = requires(T t, T::iterator it) {
+  { t.assign(it, it) } -> std::same_as<void>;
+};
 
 // constexpr void assign_range(R&& rg);
-template <typename T, typename R, typename = void>
-struct has_assign_range : std::false_type {};
 template <typename T, typename R>
-struct has_assign_range<T, R,
-                        std::void_t<decltype(std::declval<T &>().assign_range(
-                            std::declval<R &&>()))>> : std::true_type {};
+concept has_assign_range = requires(T t, R rg) {
+  { t.assign_range(rg) } -> std::same_as<void>;
+};
 
 // constexpr void assign(size_type n, const T& u);
-template <typename T, typename = void>
-struct has_assign_size : std::false_type {};
 template <typename T>
-struct has_assign_size<T, std::void_t<decltype(std::declval<T>().assign(
-                              std::declval<typename T::size_type>(),
-                              std::declval<typename T::const_reference>()))>>
-    : std::true_type {};
+concept has_assign_size = requires(T t, T::size_type n, T::const_reference u) {
+  { t.assign(n, u) } -> std::same_as<void>;
+};
 
 // constexpr void assign(initializer_list il);
-template <typename T, typename = void>
-struct has_assign_initializer : std::false_type {};
 template <typename T>
-struct has_assign_initializer<
-    T, std::void_t<decltype(std::declval<T>().assign(
-           std::declval<std::initializer_list<typename T::value_type>>()))>>
-    : std::true_type {};
+concept has_assign_initializer =
+    requires(T t, std::initializer_list<typename T::value_type> il) {
+      { t.assign(il) } -> std::same_as<void>;
+    };
 
 // constexpr void resize(size_type sz);
-template <typename T, typename = void> struct has_resize : std::false_type {};
 template <typename T>
-struct has_resize<T, std::void_t<decltype(std::declval<T>().resize(
-                         std::declval<typename T::size_type>()))>>
-    : std::true_type {};
+concept has_resize = requires(T t, T::size_type sz) {
+  { t.resize(sz) } -> std::same_as<void>;
+};
 
 // constexpr void resize(size_type sz, const T& c);
-template <typename T, typename = void>
-struct has_resize_ref : std::false_type {};
 template <typename T>
-struct has_resize_ref<T, std::void_t<decltype(std::declval<T>().resize(
-                             std::declval<typename T::size_type>(),
-                             std::declval<typename T::const_reference>()))>>
-    : std::true_type {};
+concept has_resize_ref =
+    requires(T t, typename T::size_type sz, T::const_reference c) {
+      { t.resize(sz, c) } -> std::same_as<void>;
+    };
 
 // void reserve(size_type n);
-template <typename T, typename = void> struct has_reserve : std::false_type {};
 template <typename T>
-struct has_reserve<T, std::void_t<decltype(std::declval<T>().reserve(
-                          std::declval<typename T::size_type>()))>>
-    : std::true_type {};
+concept has_reserve = requires(T t, T::size_type n) {
+  { t.reserve(n) } -> std::same_as<void>;
+};
 
 // constexpr reference at(size_type n);
-template <typename T, typename = void> struct has_at : std::false_type {};
 template <typename T>
-struct has_at<T, std::void_t<decltype(std::declval<T>().at(
-                     std::declval<typename T::size_type>()))>>
-    : std::true_type {};
+concept has_at = requires(T t, T::size_type n) {
+  { t.at(n) } -> std::same_as<typename T::reference>;
+};
 
 // constexpr const_reference at(size_type n) const;
-template <typename T, typename = void> struct has_const_at : std::false_type {};
 template <typename T>
-struct has_const_at<T, std::void_t<decltype(std::declval<const T>().at(
-                           std::declval<typename T::size_type>()))>>
-    : std::true_type {};
+concept has_const_at = requires(const T t, T::size_type n) {
+  { t.at(n) } -> std::same_as<typename T::const_reference>;
+};
 
-// emplace_back(Args&&... args);
-template <typename T, typename = void>
-struct has_emplace_back : std::false_type {};
+// constexpr reference emplace_back(Args&&... args);
 template <typename T>
-struct has_emplace_back<T, std::void_t<decltype(std::declval<T>().emplace_back(
-                               std::declval<typename T::value_type>()))>>
-    : std::true_type {};
+concept has_emplace_back = requires(T t, T::value_type v) {
+  { t.emplace_back(v) } -> std::same_as<typename T::reference>;
+};
 
 // constexpr reference push_back(const T& x);
-template <typename T, typename = void>
-struct has_push_back_const : std::false_type {};
 template <typename T>
-struct has_push_back_const<T,
-                           std::void_t<decltype(std::declval<T>().push_back(
-                               std::declval<typename T::const_reference>()))>>
-    : std::true_type {};
+concept has_push_back_const = requires(T t, typename T::const_reference x) {
+  { t.push_back(x) } -> std::same_as<typename T::reference>;
+};
 
 // constexpr reference push_back(T&& x);
-template <typename T, typename = void>
-struct has_push_back_rv : std::false_type {};
 template <typename T>
-struct has_push_back_rv<T, std::void_t<decltype(std::declval<T>().push_back(
-                               std::declval<typename T::value_type>()))>>
-    : std::true_type {};
+concept has_push_back_rv = requires(T t, typename T::value_type x) {
+  {
+    t.push_back(static_cast<typename T::value_type &&>(x))
+  } -> std::same_as<typename T::reference>;
+};
 
 // constexpr void append_range(R&& rg);
-template <typename T, typename R, typename = void>
-struct has_append_range : std::false_type {};
 template <typename T, typename R>
-struct has_append_range<
-    T, R,
-    std::void_t<decltype(std::declval<T>().append_range(std::declval<R &&>()))>>
-    : std::true_type {};
+concept has_append_range = requires(T t, R &&r) {
+  { t.append_range(r) } -> std::same_as<void>;
+};
 
 // constexpr iterator emplace(const_iterator position, Args&&... args);
-template <typename T, typename = void> struct has_emplace : std::false_type {};
 template <typename T>
-struct has_emplace<T, std::void_t<decltype(std::declval<T>().emplace(
-                          std::declval<typename T::const_iterator>(),
-                          std::declval<typename T::value_type>()))>>
-    : std::true_type {};
+concept has_emplace = requires(T t, T::const_iterator it, T::value_type v) {
+  { t.emplace(it, v) } -> std::same_as<typename T::iterator>;
+};
 
 // constexpr iterator insert(const_iterator position, const T& x);
-template <typename T, typename = void>
-struct has_insert_const : std::false_type {};
 template <typename T>
-struct has_insert_const<T, std::void_t<decltype(std::declval<T>().insert(
-                               std::declval<typename T::const_iterator>(),
-                               std::declval<typename T::const_reference>()))>>
-    : std::true_type {};
+concept has_insert_const =
+    requires(T t, T::const_iterator it, T::const_reference x) {
+      { t.insert(it, x) } -> std::same_as<typename T::iterator>;
+    };
 
 // constexpr iterator insert(const_iterator position, T&& x);
-template <typename T, typename = void>
-struct has_insert_rv : std::false_type {};
 template <typename T>
-struct has_insert_rv<T, std::void_t<decltype(std::declval<T>().insert(
-                            std::declval<typename T::const_iterator>(),
-                            std::declval<typename T::value_type>()))>>
-    : std::true_type {};
+concept has_insert_rv = requires(T t, T::const_iterator it, T::value_type &&x) {
+  {
+    t.insert(it, static_cast<typename T::value_type &&>(x))
+  } -> std::same_as<typename T::iterator>;
+};
 
 // constexpr iterator insert(const_iterator position, size_type n, const T& x);
-template <typename T, typename = void>
-struct has_insert_size : std::false_type {};
 template <typename T>
-struct has_insert_size<T, std::void_t<decltype(std::declval<T>().insert(
-                              std::declval<typename T::const_iterator>(),
-                              std::declval<typename T::size_type>(),
-                              std::declval<typename T::const_reference>()))>>
-    : std::true_type {};
+concept has_insert_size =
+    requires(T t, T::const_iterator it, T::size_type n, T::const_reference x) {
+      { t.insert(it, n, x) } -> std::same_as<typename T::iterator>;
+    };
 
 // constexpr iterator insert(const_iterator position, InputIterator first,
 // InputIterator last);
-template <typename T, typename = void>
-struct has_insert_iterator : std::false_type {};
 template <typename T>
-struct has_insert_iterator<T, std::void_t<decltype(std::declval<T>().insert(
-                                  std::declval<typename T::const_iterator>(),
-                                  std::declval<typename T::iterator>(),
-                                  std::declval<typename T::iterator>()))>>
-    : std::true_type {};
+concept has_insert_iterator =
+    requires(T t, T::const_iterator it, T::iterator first, T::iterator last) {
+      { t.insert(it, first, last) } -> std::same_as<typename T::iterator>;
+    };
 
 // InputIterator last); constexpr iterator insert_range(const_iterator position,
 // R&& rg);
-template <typename T, typename R, typename = void>
-struct has_insert_range : std::false_type {};
 template <typename T, typename R>
-struct has_insert_range<
-    T, R,
-    std::void_t<decltype(std::declval<T>().insert_range(
-        std::declval<typename T::const_iterator>(), std::declval<R &&>()))>>
-    : std::true_type {};
+concept has_insert_range = requires(T t, T::const_iterator it, R &&r) {
+  { t.insert_range(it, r) } -> std::same_as<typename T::iterator>;
+};
 
 //  constexpr iterator insert(const_iterator position, initializer_list il);
-template <typename T, typename = void>
-struct has_insert_initializer : std::false_type {};
 template <typename T>
-struct has_insert_initializer<
-    T, std::void_t<decltype(std::declval<T>().insert(
-           std::declval<typename T::const_iterator>(),
-           std::declval<std::initializer_list<typename T::value_type>>()))>>
-    : std::true_type {};
+concept has_insert_initializer =
+    requires(T t, typename T::const_iterator it,
+             std::initializer_list<typename T::value_type> il) {
+      { t.insert(it, il) } -> std::same_as<typename T::iterator>;
+    };
 
 TEST(Freestanding, deleted) {
 
@@ -213,85 +172,85 @@ TEST(Freestanding, deleted) {
   static_assert(!std::is_assignable_v<FIV &, initializer_list>);
 
   // constexpr void assign(InputIterator first, InputIterator last)
-  static_assert(has_assign_iterator<IV>::value);
-  static_assert(!has_assign_iterator<FIV>::value);
+  static_assert(has_assign_iterator<IV>);
+  static_assert(!has_assign_iterator<FIV>);
 
   // constexpr void assign_range(R&& rg);
-  static_assert(has_assign_range<IV, range>::value);
-  static_assert(!has_assign_range<FIV, range>::value);
+  static_assert(has_assign_range<IV, range>);
+  static_assert(!has_assign_range<FIV, range>);
 
   // constexpr void assign(size_type n, const T& u);
-  static_assert(has_assign_size<IV>::value);
-  static_assert(!has_assign_size<FIV>::value);
+  static_assert(has_assign_size<IV>);
+  static_assert(!has_assign_size<FIV>);
 
   // constexpr void assign(initializer_list il);
-  static_assert(has_assign_initializer<IV>::value);
-  static_assert(!has_assign_initializer<FIV>::value);
+  static_assert(has_assign_initializer<IV>);
+  static_assert(!has_assign_initializer<FIV>);
 
   // constexpr void resize(size_type sz);
-  static_assert(has_resize<IV>::value);
-  static_assert(!has_resize<FIV>::value);
+  static_assert(has_resize<IV>);
+  static_assert(!has_resize<FIV>);
 
   // constexpr void resize(size_type sz, const T& c);
-  static_assert(has_resize_ref<IV>::value);
-  static_assert(!has_resize_ref<FIV>::value);
+  static_assert(has_resize_ref<IV>);
+  static_assert(!has_resize_ref<FIV>);
 
   // void reserve(size_type n);
-  static_assert(has_reserve<IV>::value);
-  static_assert(!has_reserve<FIV>::value);
+  static_assert(has_reserve<IV>);
+  static_assert(!has_reserve<FIV>);
 
   // constexpr reference at(size_type n);
-  static_assert(has_at<IV>::value);
-  static_assert(!has_at<FIV>::value);
+  static_assert(has_at<IV>);
+  static_assert(!has_at<FIV>);
 
   // constexpr const_reference at(size_type n) const;
-  static_assert(has_const_at<IV>::value);
-  static_assert(!has_const_at<FIV>::value);
+  static_assert(has_const_at<IV>);
+  static_assert(!has_const_at<FIV>);
 
   // emplace_back(Args&&... args);
-  static_assert(has_emplace_back<IV>::value);
-  static_assert(!has_emplace_back<FIV>::value);
+  static_assert(has_emplace_back<IV>);
+  static_assert(!has_emplace_back<FIV>);
 
   // constexpr reference push_back(const T& x);
-  static_assert(has_push_back_const<IV>::value);
-  static_assert(!has_push_back_const<FIV>::value);
+  static_assert(has_push_back_const<IV>);
+  static_assert(!has_push_back_const<FIV>);
 
   // constexpr reference push_back(T&& x);
-  static_assert(has_push_back_rv<IV>::value);
-  static_assert(!has_push_back_rv<FIV>::value);
+  static_assert(has_push_back_rv<IV>);
+  static_assert(!has_push_back_rv<FIV>);
 
   // constexpr void append_range(R&& rg);
-  static_assert(has_append_range<IV, range>::value);
-  static_assert(!has_append_range<FIV, range>::value);
+  static_assert(has_append_range<IV, range>);
+  static_assert(!has_append_range<FIV, range>);
 
   // constexpr iterator emplace(const_iterator position, Args&&... args);
-  static_assert(has_emplace<IV>::value);
-  static_assert(!has_emplace<FIV>::value);
+  static_assert(has_emplace<IV>);
+  static_assert(!has_emplace<FIV>);
 
   // constexpr iterator insert(const_iterator position, const T& x);
-  static_assert(has_insert_const<IV>::value);
-  static_assert(!has_insert_const<FIV>::value);
+  static_assert(has_insert_const<IV>);
+  static_assert(!has_insert_const<FIV>);
 
   // constexpr iterator insert(const_iterator position, T&& x);
-  static_assert(has_insert_rv<IV>::value);
-  static_assert(!has_insert_rv<FIV>::value);
+  static_assert(has_insert_rv<IV>);
+  static_assert(!has_insert_rv<FIV>);
 
   // constexpr iterator insert(const_iterator position, size_type n, T& x);
-  static_assert(has_insert_size<IV>::value);
-  static_assert(!has_insert_size<FIV>::value);
+  static_assert(has_insert_size<IV>);
+  static_assert(!has_insert_size<FIV>);
 
   // constexpr iterator insert(const_iterator position, InputIterator first,
-  static_assert(has_insert_iterator<IV>::value);
-  static_assert(!has_insert_iterator<FIV>::value);
+  static_assert(has_insert_iterator<IV>);
+  static_assert(!has_insert_iterator<FIV>);
 
   // InputIterator last); constexpr iterator insert_range(const_iterator
   // position, R&& rg);
-  static_assert(has_insert_range<IV, range>::value);
-  static_assert(!has_insert_range<FIV, range>::value);
+  static_assert(has_insert_range<IV, range>);
+  static_assert(!has_insert_range<FIV, range>);
 
   //  constexpr iterator insert(const_iterator position, initializer_list il);
-  static_assert(has_insert_initializer<IV>::value);
-  static_assert(!has_insert_initializer<FIV>::value);
+  static_assert(has_insert_initializer<IV>);
+  static_assert(!has_insert_initializer<FIV>);
 
   EXPECT_TRUE(true);
 }