[NFC][libc++][tests] Move directories under stringstream

[pfusik]

Please land it for me. I have no commit access.

libcxx/test/std/input.output/string.streams/stringstream/stringstream.assign/member_swap.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
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // void swap(basic_stringstream& rhs);
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
         std::stringstream ss;
         ss.swap(ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == "456 1236 ");
         ss0 << i << ' ' << 123;
         assert(ss0.str() == "456 123");
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         std::wstringstream ss0(L" 123 456 ");
         std::wstringstream ss;
         ss.swap(ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
         ss0 << i << ' ' << 123;
         assert(ss0.str() == L"456 123");
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream/stringstream.assign/move.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
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // basic_stringstream& operator=(basic_stringstream&& rhs);
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
         std::stringstream ss;
         ss = std::move(ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == "456 1236 ");
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         std::wstringstream ss0(L" 123 456 ");
         std::wstringstream ss;
         ss = std::move(ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
     }
 #endif
 
   return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream/stringstream.assign/nonmember_swap.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
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // template <class charT, class traits, class Allocator>
 //   void
 //   swap(basic_stringstream<charT, traits, Allocator>& x,
 //        basic_stringstream<charT, traits, Allocator>& y);
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
         std::stringstream ss;
         swap(ss, ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == "456 1236 ");
         ss0 << i << ' ' << 123;
         assert(ss0.str() == "456 123");
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         std::wstringstream ss0(L" 123 456 ");
         std::wstringstream ss;
         swap(ss, ss0);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
         ss0 << i << ' ' << 123;
         assert(ss0.str() == L"456 123");
     }
 #endif
 
   return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream/stringstream.cons/default.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
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // explicit basic_stringstream(ios_base::openmode which = ios_base::out | ios_base::in); // before C++20
 // basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}            // C++20
 // explicit basic_stringstream(ios_base::openmode which);                                // C++20
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 #if TEST_STD_VER >= 11
 #include "test_convertible.h"
 
 template <typename S>
 void test() {
   static_assert(test_convertible<S>(), "");
   static_assert(!test_convertible<S, std::ios_base::openmode>(), "");
 }
 #endif
 
 int main(int, char**)
 {
     {
         std::stringstream ss;
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == "");
     }
     {
         std::stringstream ss(std::ios_base::in);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == "");
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         std::wstringstream ss;
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L"");
     }
     {
         std::wstringstream ss(std::ios_base::in);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L"");
     }
 #endif
 
 #if TEST_STD_VER >= 11
     test<std::stringstream>();
 #  ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<std::wstringstream>();
 #   endif
 #endif
 
     return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream/stringstream.cons/move.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
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // basic_stringstream(basic_stringstream&& rhs);
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
         std::stringstream ss(std::move(ss0));
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == "456 1236 ");
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         std::wstringstream ss0(L" 123 456 ");
         std::wstringstream ss(std::move(ss0));
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
     }
 #endif
 
   return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream/stringstream.cons/move2.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // basic_stringstream(basic_stringstream&& rhs);
 
 #include <sstream>
 #include <vector>
 #include <string>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::vector<std::istringstream> vecis;
     vecis.push_back(std::istringstream());
     vecis.back().str("hub started at [00 6b 8b 45 69]");
     vecis.push_back(std::istringstream());
     vecis.back().str("hub started at [00 6b 8b 45 69]");
     for (std::size_t n = 0; n < vecis.size(); n++)
     {
         assert(vecis[n].str().size() == 31);
         vecis[n].seekg(0, std::ios_base::beg);
         assert(vecis[n].str().size() == 31);
     }
 
   return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream/stringstream.cons/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
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // explicit basic_stringstream(const basic_string<charT,traits,Allocator>& str,
 //                             ios_base::openmode which = ios_base::out|ios_base::in);
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 template<typename T>
 struct NoDefaultAllocator : std::allocator<T>
 {
   template<typename U> struct rebind { using other = NoDefaultAllocator<U>; };
   NoDefaultAllocator(int id_) : id(id_) { }
   template<typename U> NoDefaultAllocator(const NoDefaultAllocator<U>& a) : id(a.id) { }
   int id;
 };
 
 
 int main(int, char**)
 {
     {
         std::stringstream ss(" 123 456 ");
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == "456 1236 ");
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         std::wstringstream ss(L" 123 456 ");
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
     }
 #endif
     { // This is https://llvm.org/PR33727
         typedef std::basic_string   <char, std::char_traits<char>, NoDefaultAllocator<char> > S;
         typedef std::basic_stringbuf<char, std::char_traits<char>, NoDefaultAllocator<char> > SB;
 
         S s(NoDefaultAllocator<char>(1));
         SB sb(s);
         // This test is not required by the standard, but *where else* could it get the allocator?
         assert(sb.str().get_allocator() == s.get_allocator());
     }
 
   return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream/stringstream.members/gcount.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: 32-bit-pointer
 
 // Test that tellp() does not break the stringstream after INT_MAX, due to use
 // of pbump() that accept int.
 
 #include <cassert>
 #include <climits>
 #include <sstream>
 #include <string>
 
 int main(int, char**) {
   std::stringstream ss;
   std::string payload(INT_MAX - 1, '\0');
 
   ss.write(payload.data(), payload.size());
   assert(ss.tellp() == INT_MAX - 1);
 
   ss.write("a", 1);
   assert(ss.tellp() == INT_MAX);
 
   ss.write("b", 1);
   assert(ss.tellp() == INT_MAX + 1ULL);
   // it fails only after previous tellp() corrupts the internal field with int
   // overflow
   assert(ss.tellp() == INT_MAX + 1ULL);
 
   return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream/stringstream.members/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
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // void str(const basic_string<charT,traits,Allocator>& str);
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::stringstream ss(" 123 456 ");
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == " 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == "456 1236 ");
         ss.str("5466 89 ");
         ss >> i;
         assert(i == 5466);
         ss >> i;
         assert(i == 89);
         ss << i << ' ' << 321;
         assert(ss.str() == "89 3219 ");
     }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
         std::wstringstream ss(L" 123 456 ");
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L" 123 456 ");
         int i = 0;
         ss >> i;
         assert(i == 123);
         ss >> i;
         assert(i == 456);
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
         ss.str(L"5466 89 ");
         ss >> i;
         assert(i == 5466);
         ss >> i;
         assert(i == 89);
         ss << i << ' ' << 321;
         assert(ss.str() == L"89 3219 ");
     }
 #endif
     {
         std::stringstream ss;
         ss.write("\xd1", 1);
         assert(ss.str().length() == 1);
     }
 
   return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream/stringstream.members/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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // basic_string_view<charT, traits> view() const noexcept;
 
 #include <sstream>
 #include <cassert>
 #include <type_traits>
 
 #include "make_string.h"
 #include "test_macros.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT>
 struct my_char_traits : public std::char_traits<CharT> {};
 
 template <class CharT>
 static void test() {
   std::basic_stringstream<CharT> ss(STR(" 123 456 "));
   static_assert(noexcept(ss.view()));
   assert(ss.view() == SV(" 123 456 "));
   int i = 0;
   ss >> i;
   assert(i == 123);
   ss >> i;
   assert(i == 456);
   ss << i << ' ' << 123;
   assert(ss.view() == SV("456 1236 "));
   ss.str(STR("5466 89 "));
   ss >> i;
   assert(i == 5466);
   ss >> i;
   assert(i == 89);
   ss << i << ' ' << 321;
   assert(ss.view() == SV("89 3219 "));
 
   const std::basic_stringstream<CharT> css(STR("abc"));
   static_assert(noexcept(css.view()));
   assert(css.view() == SV("abc"));
 
   std::basic_stringstream<CharT, my_char_traits<CharT>> tss;
   static_assert(std::is_same_v<decltype(tss.view()), std::basic_string_view<CharT, my_char_traits<CharT>>>);
 }
 
 int main(int, char**) {
   test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
   std::stringstream ss;
   ss.write("\xd1", 1);
   assert(ss.view().length() == 1);
   return 0;
 }