| //===----------------------------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 |
| |
| // <string> |
| |
| // template<class Operation> |
| // void resize_and_overwrite(size_type n, Operation op) |
| |
| #include <algorithm> |
| #include <cassert> |
| #include <string> |
| |
| #include "make_string.h" |
| #include "test_macros.h" |
| |
| template <class S> |
| constexpr void test_appending(std::size_t k, size_t N, size_t new_capacity) { |
| assert(N > k); |
| assert(new_capacity >= N); |
| auto s = S(k, 'a'); |
| s.resize_and_overwrite(new_capacity, [&](auto* p, auto n) { |
| assert(n == new_capacity); |
| LIBCPP_ASSERT(s.size() == new_capacity); |
| LIBCPP_ASSERT(s.begin().base() == p); |
| assert(std::all_of(p, p + k, [](const auto ch) { return ch == 'a'; })); |
| std::fill(p + k, p + n, 'b'); |
| p[n] = 'c'; // will be overwritten |
| return N; |
| }); |
| const S expected = S(k, 'a') + S(N - k, 'b'); |
| assert(s == expected); |
| assert(s.c_str()[N] == '\0'); |
| } |
| |
| template <class S> |
| constexpr void test_truncating(std::size_t o, size_t N) { |
| assert(N < o); |
| auto s = S(o, 'a'); |
| s.resize_and_overwrite(N, [&](auto* p, auto n) { |
| assert(n == N); |
| LIBCPP_ASSERT(s.size() == n); |
| LIBCPP_ASSERT(s.begin().base() == p); |
| assert(std::all_of(p, p + n, [](auto ch) { return ch == 'a'; })); |
| p[n - 1] = 'b'; |
| p[n] = 'c'; // will be overwritten |
| return n; |
| }); |
| const S expected = S(N - 1, 'a') + S(1, 'b'); |
| assert(s == expected); |
| assert(s.c_str()[N] == '\0'); |
| } |
| |
| template <class CharT> |
| constexpr bool test() { |
| using S = std::basic_string<CharT>; |
| test_appending<S>(10, 15, 15); |
| test_appending<S>(10, 15, 20); |
| test_appending<S>(10, 40, 40); |
| test_appending<S>(10, 40, 50); |
| test_appending<S>(30, 35, 35); |
| test_appending<S>(30, 35, 45); |
| test_appending<S>(10, 15, 30); |
| test_truncating<S>(15, 10); |
| test_truncating<S>(40, 35); |
| test_truncating<S>(40, 10); |
| |
| return true; |
| } |
| |
| void test_value_categories() { |
| std::string s; |
| s.resize_and_overwrite(10, [](char*&&, std::size_t&&) { return 0; }); |
| s.resize_and_overwrite(10, [](char* const&, const std::size_t&) { return 0; }); |
| struct RefQualified { |
| int operator()(char*, std::size_t) && { return 0; } |
| }; |
| s.resize_and_overwrite(10, RefQualified{}); |
| } |
| |
| int main(int, char**) { |
| test<char>(); |
| test<char8_t>(); |
| test<char16_t>(); |
| test<char32_t>(); |
| |
| static_assert(test<char>()); |
| static_assert(test<char8_t>()); |
| static_assert(test<char16_t>()); |
| static_assert(test<char32_t>()); |
| |
| #ifndef TEST_HAS_NO_WIDE_CHARACTERS |
| test<wchar_t>(); |
| static_assert(test<wchar_t>()); |
| #endif |
| return 0; |
| } |