String tests include "test_macros.h"

[zoecarver]

Summary

This patch adds test_macros.h to any string tests that use TEST_STD_VER. All tests should include test_macros.h but, I didn't want to make this patch to big, so I am starting with only these files. I can make another patch for the rest of string or add it to this one if you want.

[zoecarver]

Sorry if you spent a lot of time looking over this. I meant to close it (and forgot). Marshall and I talked a bit about this, and he is going to "take over" and commit the other ~3200 files that need changes.

[ldionne]

SGTM. It took only a minute to review!

test/std/strings/basic.string/string.access/back.pass.cpp

 
 #ifdef _LIBCPP_DEBUG
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
     ASSERT_SAME_TYPE(decltype( s.back()), typename S::reference);

test/std/strings/basic.string/string.access/db_back.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     S s(1, '\0');
     assert(s.back() == 0);

test/std/strings/basic.string/string.access/db_cback.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     const S s;
     assert(s.back() == 0);

test/std/strings/basic.string/string.access/db_cfront.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     const S s;
     assert(s.front() == 0);

test/std/strings/basic.string/string.access/db_cindex.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     const S s;
     assert(s[0] == 0);

test/std/strings/basic.string/string.access/db_front.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     S s(1, '\0');
     assert(s.front() == 0);

test/std/strings/basic.string/string.access/db_index.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     S s;
     assert(s[0] == 0);

test/std/strings/basic.string/string.access/front.pass.cpp

 
 #ifdef _LIBCPP_DEBUG
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
     ASSERT_SAME_TYPE(decltype( s.front()), typename S::reference);

test/std/strings/basic.string/string.access/index.pass.cpp

 
 #ifdef _LIBCPP_DEBUG
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     S s("0123456789");
     const S& cs = s;

test/std/strings/basic.string/string.capacity/clear.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // void clear();
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s)
 {
     s.clear();
     assert(s.size() == 0);

test/std/strings/basic.string/string.capacity/length.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type length() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s)
 {
     assert(s.length() == s.size());
 }

test/std/strings/basic.string/string.capacity/max_size.pass.cpp

 //    returns null.
 // 2. If allocator_may_return_null=1 then they will fail because the allocation
 //    is too large to succeed.
 // UNSUPPORTED: sanitizer-new-delete
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test1(const S& s)
 {
     S s2(s);
     const size_t sz = s2.max_size() - 1;

test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp

 // <string>
 
 // size_type max_size() const;
 
 #include <string>
 #include <cassert>
 #include <stdexcept>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s)
 {
     assert(s.max_size() >= s.size());
     S s2(s);

test/std/strings/basic.string/string.capacity/size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type size() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, typename S::size_type c)
 {
     assert(s.size() == c);
 }

test/std/strings/basic.string/string.iterators/begin.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 //       iterator begin();
 // const_iterator begin() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
     typename S::iterator b = s.begin();

test/std/strings/basic.string/string.iterators/cbegin.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // const_iterator cbegin() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s)
 {
     typename S::const_iterator cb = s.cbegin();
     if (!s.empty())

test/std/strings/basic.string/string.iterators/cend.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // const_iterator cend() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s)
 {
     typename S::const_iterator ce = s.cend();
     assert(ce == s.end());

test/std/strings/basic.string/string.iterators/crbegin.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // const_reverse_iterator crbegin() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s)
 {
     typename S::const_reverse_iterator cb = s.crbegin();
     if (!s.empty())

test/std/strings/basic.string/string.iterators/crend.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // const_reverse_iterator crend() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s)
 {
     typename S::const_reverse_iterator ce = s.crend();
     assert(ce == s.rend());

test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     S s1;
     S s2;

test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string S;
     S s1;
     S s2;

test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string C;
     C c(1, '\0');
     C::iterator i = c.begin();

test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string C;
     C c(1, '\0');
     C::iterator i = c.begin();

test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string C;
     C c(1, '\0');
     C::iterator i = c.end();

test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string C;
     C c(1, '\0');
     C::iterator i = c.begin();

test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef std::string C;
     C c(1, '\0');
     C::iterator i = c.end();

test/std/strings/basic.string/string.iterators/end.pass.cpp

 
 //       iterator end();
 // const_iterator end() const;
 
 #include <string>
 #include <cassert>
 #include <cstddef>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
     typename S::iterator e = s.end();

test/std/strings/basic.string/string.iterators/rbegin.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 //       reverse_iterator rbegin();
 // const_reverse_iterator rbegin() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
     typename S::reverse_iterator b = s.rbegin();

test/std/strings/basic.string/string.iterators/rend.pass.cpp

 
 //       reverse_iterator rend();
 // const_reverse_iterator rend() const;
 
 #include <string>
 #include <cassert>
 #include <cstddef>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
     typename S::reverse_iterator e = s.rend();

test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class InputIterator>
 //   basic_string& append(InputIterator first, InputIterator last);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
 void
 test(S s, It first, It last, S expected)
 {
     s.append(first, last);

test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
 void
 test(S s, typename S::difference_type pos, It first, It last, S expected)
 {
     typename S::const_iterator p = s.cbegin() + pos;

test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

 // template<class InputIterator>
 //   basic_string&
 //   replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);
 
 #include <string>
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 #include "test_iterators.h"
 
 template <class S, class It>
 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l, S expected)
 {
     typename S::size_type old_size = s.size();

test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp

 //   replace(const_iterator i1, const_iterator i2, const charT* s);
 
 #include <stdio.h>
 
 #include <string>
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, const typename S::value_type* str, S expected)
 {
     typename S::size_type old_size = s.size();
     typename S::const_iterator first = s.begin() + pos1;

test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp

 //   basic_ostream<charT, traits>&
 //   operator<<(basic_ostream<charT, traits>& os,
 //              const basic_string<charT,traits,Allocator>& str);
 
 #include <string>
 #include <sstream>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
         std::ostringstream out;
         std::string s("some text");
         out << s;

test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator!=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator!=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp

 
 // template<class charT, class traits, class Allocator>
 //   bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
 //                   const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs != rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator==(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp

 
 // template<class charT, class traits, class Allocator>
 //   bool operator==(const basic_string<charT,traits,Allocator>& lhs,
 //                   const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs == rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator>(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator>(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp

 
 // template<class charT, class traits, class Allocator>
 //   bool operator>(const basic_string<charT,traits,Allocator>& lhs,
 //                  const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs > rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator>=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator>=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp

 
 // template<class charT, class traits, class Allocator>
 //   bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
 //                  const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs >= rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator<(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator<(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp

 
 // template<class charT, class traits, class Allocator>
 //   bool operator<(const basic_string<charT,traits,Allocator>& lhs,
 //                  const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs < rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator<=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const typename S::value_type* lhs, const S& rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   bool operator<=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const typename S::value_type* rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp

 
 // template<class charT, class traits, class Allocator>
 //   bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
 //                  const basic_string<charT,traits,Allocator>& rhs);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& lhs, const S& rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& lhs, SV rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }

test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // we get this comparison "for free" because the string implicitly converts to the string_view
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(SV lhs, const S& rhs, bool x)
 {
     assert((lhs <= rhs) == x);
 }

test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // const charT* c_str() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s)
 {
     typedef typename S::traits_type T;
     const typename S::value_type* str = s.c_str();

test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // allocator_type get_allocator() const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::allocator_type& a)
 {
     assert(s.get_allocator() == a);

test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // int compare(const charT *s) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;

test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // int compare(const basic_string_view sv) const
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;

test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_first_not_of(charT c, size_type pos = 0) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find_first_not_of(c, pos) == x);

test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_first_not_of(const charT* s, size_type pos = 0) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find_first_not_of(str, pos) == x);

test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     assert(s.find_first_not_of(str, pos, n) == x);

test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_first_not_of(basic_string_view sv, size_type pos = 0) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     assert(s.find_first_not_of(sv, pos) == x);
     if (x != S::npos)

test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_first_of(charT c, size_type pos = 0) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find_first_of(c, pos) == x);

test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_first_of(const charT* s, size_type pos = 0) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find_first_of(str, pos) == x);

test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_first_of(const charT* s, size_type pos, size_type n) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     assert(s.find_first_of(str, pos, n) == x);

test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_first_of(const basic_string_view sv, size_type pos = 0) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     assert(s.find_first_of(sv, pos) == x);
     if (x != S::npos)

test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_last_not_of(charT c, size_type pos = npos) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find_last_not_of(c, pos) == x);

test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_last_not_of(const charT* s, size_type pos = npos) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find_last_not_of(str, pos) == x);

test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     assert(s.find_last_not_of(str, pos, n) == x);

test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_last_not_of(basic_string_view sv, size_type pos = npos) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     assert(s.find_last_not_of(sv, pos) == x);
     if (x != S::npos)

test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_last_of(charT c, size_type pos = npos) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find_last_of(c, pos) == x);

test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_last_of(const charT* s, size_type pos = npos) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find_last_of(str, pos) == x);

test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_last_of(const charT* s, size_type pos, size_type n) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     assert(s.find_last_of(str, pos, n) == x);

test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find_last_of(const basic_string_view sv, size_type pos = npos) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     assert(s.find_last_of(sv, pos) == x);
     if (x != S::npos)

test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find(charT c, size_type pos = 0) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find(c, pos) == x);

test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find(const charT* s, size_type pos = 0) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.find(str, pos) == x);

test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find(const charT* s, size_type pos, size_type n) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type n, typename S::size_type x)
 {
     assert(s.find(str, pos, n) == x);

test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type find(basic_string_view sv, size_type pos = 0) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     assert(s.find(sv, pos) == x);
     if (x != S::npos)

test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type rfind(charT c, size_type pos = npos) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, typename S::value_type c, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.rfind(c, pos) == x);

test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type rfind(const charT* s, size_type pos = npos) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
      typename S::size_type x)
 {
     assert(s.rfind(str, pos) == x);

test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type rfind(const charT* s, size_type pos, size_type n) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, const typename S::value_type* str, typename S::size_type pos,
       typename S::size_type n, typename S::size_type x)
 {
     assert(s.rfind(str, pos, n) == x);

test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // size_type rfind(basic_string_view sv, size_type pos = npos) const;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(const S& s, SV sv, typename S::size_type pos, typename S::size_type x)
 {
     assert(s.rfind(sv, pos) == x);
     if (x != S::npos)

test/std/strings/basic.string/string.require/contiguous.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // An string is a contiguous container
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 
 template <class C>
 void test_contiguous ( const C &c )
 {
     for ( size_t i = 0; i < c.size(); ++i )

test/std/strings/basic.string/types.pass.cpp

 //     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 //     static const size_type npos = -1;
 // };
 
 #include <string>
 #include <iterator>
 #include <type_traits>
 
+#include "test_macros.h"
 #include "test_traits.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class Traits, class Allocator>
 void
 test()
 {