libcxx/test/std/strings/basic.string/string.modifiers/string_append/push_back.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 // <string>
  10
  11 // void push_back(charT c) // constexpr since C++20
  12
  13 #include <string>
  14 #include <algorithm>
  15 #include <cassert>
  16
  17 #include "test_macros.h"
  18 #include "min_allocator.h"
  19 #include "asan_testing.h"
  20
  21 struct VeryLarge {
  22   long long a;
  23   char b;
  24 };
  25
  26 template <>
  27 struct std::char_traits<VeryLarge> {
  28   using char_type  = VeryLarge;
  29   using int_type   = int;
  30   using off_type   = streamoff;
  31   using pos_type   = streampos;
  32   using state_type = mbstate_t;
  33
  34   static TEST_CONSTEXPR_CXX20 void assign(char_type& c1, const char_type& c2) { c1 = c2; }
  35   static bool eq(char_type c1, char_type c2);
  36   static bool lt(char_type c1, char_type c2);
  37
  38   static int compare(const char_type* s1, const char_type* s2, std::size_t n);
  39   static std::size_t length(const char_type* s);
  40   static const char_type* find(const char_type* s, std::size_t n, const char_type& a);
  41   static char_type* move(char_type* s1, const char_type* s2, std::size_t n);
  42   static TEST_CONSTEXPR_CXX20 char_type* copy(char_type* s1, const char_type* s2, std::size_t n) {
  43     std::copy_n(s2, n, s1);
  44     return s1;
  45   }
  46   static TEST_CONSTEXPR_CXX20 char_type* assign(char_type* s, std::size_t n, char_type a) {
  47     std::fill_n(s, n, a);
  48     return s;
  49   }
  50
  51   static int_type not_eof(int_type c);
  52   static char_type to_char_type(int_type c);
  53   static int_type to_int_type(char_type c);
  54   static bool eq_int_type(int_type c1, int_type c2);
  55   static int_type eof();
  56 };
  57
  58 template <class S>
  59 TEST_CONSTEXPR_CXX20 void test(S s, typename S::value_type c, S expected) {
  60   s.push_back(c);
  61   LIBCPP_ASSERT(s.__invariants());
  62   assert(s == expected);
  63   LIBCPP_ASSERT(is_string_asan_correct(s));
  64 }
  65
  66 template <class S>
  67 TEST_CONSTEXPR_CXX20 void test_string() {
  68   test(S(), 'a', S(1, 'a'));
  69   test(S("12345"), 'a', S("12345a"));
  70   test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
  71   test(S("123abcabcdefghabcdefgh"), 'a', S("123abcabcdefghabcdefgha"));
  72   test(S("123abcabcdefghabcdefgha"), 'b', S("123abcabcdefghabcdefghab"));
  73   test(S("123abcabcdefghabcdefghab"), 'c', S("123abcabcdefghabcdefghabc"));
  74   test(S("123abcabcdefghabcdefghabc"), 'd', S("123abcabcdefghabcdefghabcd"));
  75 }
  76
  77 TEST_CONSTEXPR_CXX20 bool test() {
  78   test_string<std::string>();
  79 #if TEST_STD_VER >= 11
  80   test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
  81   test_string<std::basic_string<char, std::char_traits<char>, safe_allocator<char> > >();
  82 #endif
  83   {
  84     // https://llvm.org/PR31454
  85     std::basic_string<VeryLarge> s;
  86     VeryLarge vl = {};
  87     s.push_back(vl);
  88     s.push_back(vl);
  89     s.push_back(vl);
  90   }
  91
  92   return true;
  93 }
  94
  95 int main(int, char**) {
  96   test();
  97 #if TEST_STD_VER > 17
  98   static_assert(test());
  99 #endif
 100
 101   return 0;
 102 }