libcxx/test/std/input.output/string.streams/istringstream/istringstream.members/str.allocator_propagation.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03, c++11, c++14, c++17
  10 // TODO: Change to XFAIL once https://github.com/llvm/llvm-project/issues/40340 is fixed
  11 // UNSUPPORTED: availability-pmr-missing
  12
  13 // This test ensures that we properly propagate allocators from istringstream's
  14 // inner string object to the new string returned from .str().
  15 // `str() const&` is specified to preserve the allocator (not copy the string).
  16 // `str() &&` isn't specified, but should preserve the allocator (move the string).
  17
  18 #include <cassert>
  19 #include <memory>
  20 #include <memory_resource>
  21 #include <sstream>
  22 #include <string>
  23 #include <string_view>
  24 #include <type_traits>
  25
  26 #include "make_string.h"
  27 #include "test_allocator.h"
  28 #include "test_macros.h"
  29
  30 template <class CharT>
  31 void test_soccc_behavior() {
  32   using Alloc = SocccAllocator<CharT>;
  33   using SS    = std::basic_istringstream<CharT, std::char_traits<CharT>, Alloc>;
  34   using S     = std::basic_string<CharT, std::char_traits<CharT>, Alloc>;
  35   {
  36     SS ss = SS(std::ios_base::in, Alloc(10));
  37
  38     // [stringbuf.members]/6 specifies that the allocator is copied,
  39     // not select_on_container_copy_construction'ed.
  40     //
  41     S copied = ss.str();
  42     assert(copied.get_allocator().count_ == 10);
  43     assert(ss.rdbuf()->get_allocator().count_ == 10);
  44     assert(copied.empty());
  45
  46     // sanity-check that SOCCC does in fact work
  47     assert(S(copied).get_allocator().count_ == 11);
  48
  49     // [stringbuf.members]/10 doesn't specify the allocator to use,
  50     // but copying the allocator as-if-by moving the string makes sense.
  51     //
  52     S moved = std::move(ss).str();
  53     assert(moved.get_allocator().count_ == 10);
  54     assert(ss.rdbuf()->get_allocator().count_ == 10);
  55     assert(moved.empty());
  56   }
  57 }
  58
  59 template <class CharT,
  60           class Base = std::basic_stringbuf<CharT, std::char_traits<CharT>, std::pmr::polymorphic_allocator<CharT>>>
  61 struct StringBuf : Base {
  62   explicit StringBuf(std::pmr::memory_resource* mr) : Base(std::ios_base::in, mr) {}
  63   void public_setg(int a, int b, int c) {
  64     CharT* p = this->eback();
  65     assert(this->view().data() == p);
  66     this->setg(p + a, p + b, p + c);
  67     assert(this->eback() == p + a);
  68     assert(this->view().data() == p + a);
  69   }
  70 };
  71
  72 template <class CharT>
  73 void test_allocation_is_pilfered() {
  74   using SS = std::basic_istringstream<CharT, std::char_traits<CharT>, std::pmr::polymorphic_allocator<CharT>>;
  75   using S  = std::pmr::basic_string<CharT>;
  76   alignas(void*) char buf[80 * sizeof(CharT)];
  77   const CharT* initial =
  78       MAKE_CSTRING(CharT, "a very long string that exceeds the small string optimization buffer length");
  79   {
  80     std::pmr::set_default_resource(std::pmr::null_memory_resource());
  81     auto mr1 = std::pmr::monotonic_buffer_resource(buf, sizeof(buf), std::pmr::null_memory_resource());
  82     SS ss    = SS(S(initial, &mr1));
  83     S s      = std::move(ss).str();
  84     assert(s == initial);
  85   }
  86   {
  87     // Try moving-out-of a stringbuf whose view() is not the entire string.
  88     // This is libc++'s behavior; libstdc++ doesn't allow such stringbufs to be created.
  89     //
  90     std::pmr::set_default_resource(std::pmr::null_memory_resource());
  91     auto mr1 = std::pmr::monotonic_buffer_resource(buf, sizeof(buf), std::pmr::null_memory_resource());
  92     auto src = StringBuf<CharT>(&mr1);
  93     src.str(S(initial, &mr1));
  94     src.public_setg(2, 6, 40);
  95     SS ss(std::ios_base::in, &mr1);
  96     *ss.rdbuf() = std::move(src);
  97     LIBCPP_ASSERT(ss.view() == std::basic_string_view<CharT>(initial).substr(2, 38));
  98     S s = std::move(ss).str();
  99     LIBCPP_ASSERT(s == std::basic_string_view<CharT>(initial).substr(2, 38));
 100   }
 101 }
 102
 103 template <class CharT>
 104 void test_no_foreign_allocations() {
 105   using SS = std::basic_istringstream<CharT, std::char_traits<CharT>, std::pmr::polymorphic_allocator<CharT>>;
 106   using S  = std::pmr::basic_string<CharT>;
 107   const CharT* initial =
 108       MAKE_CSTRING(CharT, "a very long string that exceeds the small string optimization buffer length");
 109   {
 110     std::pmr::set_default_resource(std::pmr::null_memory_resource());
 111     auto mr1 = std::pmr::monotonic_buffer_resource(std::pmr::new_delete_resource());
 112     auto ss  = SS(S(initial, &mr1));
 113     assert(ss.rdbuf()->get_allocator().resource() == &mr1);
 114
 115     // [stringbuf.members]/6 specifies that the result of `str() const &`
 116     // does NOT use the default allocator; it uses the original allocator.
 117     //
 118     S copied = ss.str();
 119     assert(copied.get_allocator().resource() == &mr1);
 120     assert(ss.rdbuf()->get_allocator().resource() == &mr1);
 121     assert(copied == initial);
 122
 123     // [stringbuf.members]/10 doesn't specify the allocator to use,
 124     // but copying the allocator as-if-by moving the string makes sense.
 125     //
 126     S moved = std::move(ss).str();
 127     assert(moved.get_allocator().resource() == &mr1);
 128     assert(ss.rdbuf()->get_allocator().resource() == &mr1);
 129     assert(moved == initial);
 130   }
 131 }
 132
 133 int main(int, char**) {
 134   test_soccc_behavior<char>();
 135   test_allocation_is_pilfered<char>();
 136   test_no_foreign_allocations<char>();
 137 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 138   test_soccc_behavior<wchar_t>();
 139   test_allocation_is_pilfered<wchar_t>();
 140   test_no_foreign_allocations<wchar_t>();
 141 #endif
 142
 143   return 0;
 144 }