[libcxx-commits] [libcxx] [libc++][string] Assert resize_and_overwrite operation returns integer-like type (PR #162030)

[NagaChaitanya Vellanki via libcxx-commits]

================
@@ -77,17 +78,35 @@ constexpr bool test() {
   return true;
 }
 
-void test_value_categories() {
+constexpr bool test_value_categories() {
   std::string s;
   s.resize_and_overwrite(10, [](char*&&, std::size_t&&) { return 0; });
   LIBCPP_ASSERT(is_string_asan_correct(s));
   s.resize_and_overwrite(10, [](char* const&, const std::size_t&) { return 0; });
   LIBCPP_ASSERT(is_string_asan_correct(s));
   struct RefQualified {
-    int operator()(char*, std::size_t) && { return 0; }
+    constexpr int operator()(char*, std::size_t) && { return 0; }
   };
   s.resize_and_overwrite(10, RefQualified{});
   LIBCPP_ASSERT(is_string_asan_correct(s));
+  return true;
+}
+
+template <typename T>
+struct TestIntegerLikeReturnTypes {
+  constexpr void operator()() {
+    std::string s;
+    s.resize_and_overwrite(10, [](char* p, std::size_t n) -> T {
+      std::fill(p, p + n, 'f');
+      return n;
+    });
+    assert(s.size() == 10);
+  }
+};
----------------
chaitanyav wrote:

because thats the way most tests have been written, i followed the same convention. 

```c++
struct TestInt {
  47   │   template <class T>
  48   │   static TEST_CONSTEXPR_CXX23 bool test() {
  49   │     assert(std::isnormal(std::numeric_limits<T>::max()));
  50   │     assert(std::isnormal(std::numeric_limits<T>::lowest()) == std::is_signed<T>::value);
  51   │     assert(!std::isnormal(T(0)));
  52   │
  53   │     return true;
  54   │   }
```

```c++
struct TestFloat {
  22   │   template <class T>
  23   │   static TEST_CONSTEXPR_CXX23 bool test() {
  24   │     assert(std::isnormal(std::numeric_limits<T>::max()));
  25   │     assert(!std::isnormal(std::numeric_limits<T>::infinity()));
  26   │     assert(std::isnormal(std::numeric_limits<T>::min()));
  27   │     assert(!std::isnormal(std::numeric_limits<T>::denorm_min()));
  28   │     assert(std::isnormal(std::numeric_limits<T>::lowest()));
  29   │     assert(!std::isnormal(-std::numeric_limits<T>::infinity()));
  30   │     assert(!std::isnormal(T(0)));
  31   │     assert(!std::isnormal(std::numeric_limits<T>::quiet_NaN()));
  32   │     assert(!std::isnormal(std::numeric_limits<T>::signaling_NaN()));
  33   │
  34   │     return true;
  35   │   }
  36   │
```

```c++
struct TestFloat {
  28   │   template <class T>
  29   │   static TEST_CONSTEXPR_CXX23 bool test() {
  30   │     assert(!std::signbit(T(0)));
  31   │     assert(!std::signbit(std::numeric_limits<T>::min()));
  32   │     assert(!std::signbit(std::numeric_limits<T>::denorm_min()));
  33   │     assert(!std::signbit(std::numeric_limits<T>::max()));
  34   │     assert(!std::signbit(std::numeric_limits<T>::infinity()));
  35   │     assert(!std::signbit(std::numeric_limits<T>::quiet_NaN()));
  36   │     assert(!std::signbit(std::numeric_limits<T>::signaling_NaN()));
  37   │     assert(std::signbit(-T(0)));
  38   │     assert(std::signbit(-std::numeric_limits<T>::infinity()));
  39   │     assert(std::signbit(std::numeric_limits<T>::lowest()));
  40   │
  41   │     return true;
  42   │   }
```

https://github.com/llvm/llvm-project/pull/162030