[libc++][NFC] Remove uses of 'using namespace std;' in the test suite

[• Quuxplusone]

libcxx/test/libcxx/numerics/c.math/fdelayed-template-parsing.pass.cpp

27

This can't possibly have been accidental, can it? What's the subtle point of this test?

libcxx/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp

26

You don't need the std:: on size_t. (Compare line 29, where you left it off and it was totally fine.)
Some people put it religiously; I personally omit it religiously (on analogy to int, and because I like typing less).
Anyway, consider making lines 25 and 29 consistent (but it doesn't matter).

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp

35

This must have been intentional — trying to verify that we get no ambiguity from lookup finding both std::swap and std::filesystem::swap?? — but in this case I'm fairly sure I understand the issues involved and agree that deleting this line is fine.

Alternatively, delete using namespace fs; but keep using namespace std; — then we'd be testing that the "std::swap two-step" correctly works with path the same way it works with other types.

Obviously lines 41-42 should be made consistent with whatever you choose to do here.

libcxx/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp

10

:shipit:

libcxx/test/std/strings/basic.string.literals/literal3.pass.cpp

1

No, this one is 100% intentional. Compare literal1.cpp.
However, please add comments to each of the files... and IMHO ideally combine them into just one file, so that it will be more obvious in the future what's supposed to be different between each file.

libcxx/test/std/strings/string.view/string_view.literals/literal3.pass.cpp

1

Ditto.

libcxx/test/support/any_helpers.h

93

Oho. This double-using idiom must date back to when std::experimental::any_cast was a thing. We don't have to worry about that anymore, right?

[ldionne]

Address comments

libcxx/test/libcxx/numerics/c.math/fdelayed-template-parsing.pass.cpp

27

Indeed, good catch. I did some archeology and improved the comment at the top instead.

libcxx/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp

26

When I include <cxxxxx>, I use the stuff in namespace std:: as a matter of consistency.

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp

35

I actually added a test that checks the swap two-step but also left this one.

libcxx/test/std/strings/basic.string.literals/literal3.pass.cpp

1

Hmm, right indeed -- I went a bit quickly with this patch, thanks for looking at it diligently. I fixed it, look in the next update.

libcxx/test/support/any_helpers.h

93

Right, that was my thinking too.

libcxx/test/libcxx/numerics/c.math/fdelayed-template-parsing.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
 //
 //===----------------------------------------------------------------------===//
 
-// test that cmath builds with -fdelayed-template-parsing
+// Test that cmath builds with -fdelayed-template-parsing.
+// This is a regression test for an issue introduced in ae22f0b24231,
+// where Clang's limited support for -fdelayed-template-parsing would
+// choke on <cmath>.
 
 // REQUIRES: fdelayed-template-parsing
 // ADDITIONAL_COMPILE_FLAGS: -fdelayed-template-parsing
 
 #include <cmath>
 #include <cassert>
 
-#include "test_macros.h"
-
 int main(int, char**) {
   assert(std::isfinite(1.0));
   assert(!std::isinf(1.0));
   assert(!std::isnan(1.0));
 
   return 0;
 }
 
-using namespace std;
+using namespace std; // on purpose

libcxx/test/std/containers/associative/map/map.access/index_tuple.pass.cpp

 
 // class map
 
 // mapped_type& operator[](const key_type& k);
 
 // https://llvm.org/PR16542
 
 #include <map>
-
-
 #include <tuple>
 
-#include "test_macros.h"
-
-
-int main(int, char**)
-{
-    using namespace std;
-    map<tuple<int,int>, size_t> m;
-    m[make_tuple(2,3)]=7;
+int main(int, char**) {
+    std::map<std::tuple<int, int>, std::size_t> m;
+    m[std::make_tuple(2, 3)] = 7;
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp

 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // mapped_type& operator[](const key_type& k);
 
 // https://llvm.org/PR16542
 
-#include <unordered_map>
+#include <cstddef>
 #include <tuple>
+#include <unordered_map>
 
-#include "test_macros.h"
-
-using namespace std;
-
-struct my_hash
-{
-    size_t operator()(const tuple<int,int>&) const {return 0;}
+struct my_hash {
+    std::size_t operator()(const std::tuple<int, int>&) const { return 0; }
 };
 
-int main(int, char**)
-{
-    unordered_map<tuple<int,int>, size_t, my_hash> m;
-    m[make_tuple(2,3)]=7;
+int main(int, char**) {
+    std::unordered_map<std::tuple<int, int>, std::size_t, my_hash> m;
+    m[std::make_tuple(2, 3)] = 7;
 
     return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp

 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
 
-
 // NOTE: this is tested in path.members/path.modifiers via the member swap.
 int main(int, char**)
 {
   using namespace fs;
   const char* value1 = "foo/bar/baz";
   const char* value2 = "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG";
+  {
     path p1(value1);
     path p2(value2);
     fs::path::string_type ps1 = p1.native();
     fs::path::string_type ps2 = p2.native();
-  {
-    using namespace std; using namespace fs;
+
+    DisableAllocationGuard g;
+    swap(p1, p2);
     ASSERT_NOEXCEPT(swap(p1, p2));
     ASSERT_SAME_TYPE(void, decltype(swap(p1, p2)));
+    assert(p1.native() == ps2);
+    assert(p2.native() == ps1);
+    swap(p1, p2);
+    assert(p1.native() == ps1);
+    assert(p2.native() == ps2);
   }
+
+  // Test the swap two-step idiom
   {
+    path p1(value1);
+    path p2(value2);
+    fs::path::string_type ps1 = p1.native();
+    fs::path::string_type ps2 = p2.native();
+
     DisableAllocationGuard g;
     using namespace std;
-    using namespace fs;
     swap(p1, p2);
+    ASSERT_NOEXCEPT(swap(p1, p2));
+    ASSERT_SAME_TYPE(void, decltype(swap(p1, p2)));
     assert(p1.native() == ps2);
     assert(p2.native() == ps1);
     swap(p1, p2);
     assert(p1.native() == ps1);
     assert(p2.native() == ps2);
   }
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.literals/literals2.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
-// <chrono>
+// <complex>
 
 #include <complex>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)

libcxx/test/std/re/re.const/re.matchflag/match_prev_avail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 
 // match_prev_avail:
 //     --first is a valid iterator position. When this flag is set the flags
 //     match_not_bol and match_not_bow shall be ignored by the regular
 //     expression algorithms (30.11) and iterators (30.12)
 
-#include <cassert>
 #include <regex>
-using namespace std;
+
+#include <cassert>
+#include <string>
 
 int main(int, char**) {
   char str1[] = "\na";
   auto str1_scnd = str1 + 1;
+
   // Assert that match_prev_avail disables match_not_bol and this matches
-  assert(regex_match(str1 + 1, str1 + 2, regex("^a"),
-                     regex_constants::match_not_bol |
-                         regex_constants::match_prev_avail));
+  assert(std::regex_match(str1 + 1, str1 + 2, std::regex("^a"),
+                     std::regex_constants::match_not_bol |
+                         std::regex_constants::match_prev_avail));
   // Manually passing match_prev_avail defines that --str1 is a valid position
-  assert(regex_match(str1_scnd, regex("a"),
-                     regex_constants::match_not_bol |
-                         regex_constants::match_prev_avail));
+  assert(std::regex_match(str1_scnd, std::regex("a"),
+                     std::regex_constants::match_not_bol |
+                         std::regex_constants::match_prev_avail));
 
   //Assert that match_prev_avail disables match_not_bow and this matches
-  assert(regex_search(str1, regex("\\ba")));
-  assert(regex_match(str1 + 1, str1 + 2, regex("\\ba\\b"),
-                     regex_constants::match_not_bow |
-                         regex_constants::match_prev_avail));
-  assert(regex_search(str1_scnd, regex("\\ba"),
-                      regex_constants::match_not_bow |
-                          regex_constants::match_prev_avail));
+  assert(std::regex_search(str1, std::regex("\\ba")));
+  assert(std::regex_match(str1 + 1, str1 + 2, std::regex("\\ba\\b"),
+                     std::regex_constants::match_not_bow |
+                         std::regex_constants::match_prev_avail));
+  assert(std::regex_search(str1_scnd, std::regex("\\ba"),
+                      std::regex_constants::match_not_bow |
+                          std::regex_constants::match_prev_avail));
 
   //Assert that match_prev_avail disables both match_not_bow and match_not_bol
-  assert(regex_match(str1 + 1, str1 + 2, regex("^a"),
-                     regex_constants::match_not_bol |
-                         regex_constants::match_not_bow |
-                         regex_constants::match_prev_avail));
-  assert(regex_match(str1_scnd, regex("\\ba"),
-                     regex_constants::match_not_bol |
-                         regex_constants::match_not_bow |
-                         regex_constants::match_prev_avail));
+  assert(std::regex_match(str1 + 1, str1 + 2, std::regex("^a"),
+                     std::regex_constants::match_not_bol |
+                         std::regex_constants::match_not_bow |
+                         std::regex_constants::match_prev_avail));
+  assert(std::regex_match(str1_scnd, std::regex("\\ba"),
+                     std::regex_constants::match_not_bol |
+                         std::regex_constants::match_not_bow |
+                         std::regex_constants::match_prev_avail));
 
   // pr 42199
-  string S = " cd";
-  string::iterator Start = S.begin() + 1;
-  string::iterator End = S.end();
-  assert(regex_search(Start, End, regex("^cd")));
-
-  assert(
-      !regex_search(Start, End, regex("^cd"), regex_constants::match_not_bol));
-  assert(!regex_search(Start, End, regex(".*\\bcd\\b"),
-                       regex_constants::match_not_bow));
-  assert(!regex_search(Start, End, regex("^cd"),
-                       regex_constants::match_not_bol |
-                           regex_constants::match_not_bow));
-  assert(!regex_search(Start, End, regex(".*\\bcd\\b"),
-                       regex_constants::match_not_bol |
-                           regex_constants::match_not_bow));
-
-  assert(regex_search(Start, End, regex("^cd"),
-                      regex_constants::match_prev_avail));
-
-  assert(regex_search(Start, End, regex("^cd"),
-                      regex_constants::match_not_bol |
-                          regex_constants::match_prev_avail));
-  assert(regex_search(Start, End, regex("^cd"),
-                      regex_constants::match_not_bow |
-                          regex_constants::match_prev_avail));
-  assert(regex_match(Start, End, regex("\\bcd\\b"),
-                     regex_constants::match_not_bol |
-                         regex_constants::match_not_bow |
-                         regex_constants::match_prev_avail));
+  std::string S = " cd";
+  std::string::iterator Start = S.begin() + 1;
+  std::string::iterator End = S.end();
+  assert(std::regex_search(Start, End, std::regex("^cd")));
+
+  assert(!std::regex_search(Start, End, std::regex("^cd"),
+            std::regex_constants::match_not_bol));
+  assert(!std::regex_search(Start, End, std::regex(".*\\bcd\\b"),
+            std::regex_constants::match_not_bow));
+  assert(!std::regex_search(Start, End, std::regex("^cd"),
+            std::regex_constants::match_not_bol |
+            std::regex_constants::match_not_bow));
+  assert(!std::regex_search(Start, End, std::regex(".*\\bcd\\b"),
+            std::regex_constants::match_not_bol |
+            std::regex_constants::match_not_bow));
+
+  assert(std::regex_search(Start, End, std::regex("^cd"),
+            std::regex_constants::match_prev_avail));
+
+  assert(std::regex_search(Start, End, std::regex("^cd"),
+            std::regex_constants::match_not_bol |
+            std::regex_constants::match_prev_avail));
+  assert(std::regex_search(Start, End, std::regex("^cd"),
+            std::regex_constants::match_not_bow |
+            std::regex_constants::match_prev_avail));
+  assert(std::regex_match(Start, End, std::regex("\\bcd\\b"),
+            std::regex_constants::match_not_bol |
+            std::regex_constants::match_not_bow |
+            std::regex_constants::match_prev_avail));
   return 0;
 }

libcxx/test/std/strings/basic.string.literals/literal.pass.cpp

 #include "test_macros.h"
 
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     typedef std::u8string u8string;
 #else
     typedef std::string   u8string;
 #endif
 
-
-int main(int, char**)
+int main(int, char**) {
     {
         using namespace std::literals::string_literals;
 
-    static_assert ( std::is_same<decltype(   "Hi"s), std::string>::value, "" );
-    static_assert ( std::is_same<decltype( u8"Hi"s), u8string>::value, "" );
-    static_assert ( std::is_same<decltype(  L"Hi"s), std::wstring>::value, "" );
-    static_assert ( std::is_same<decltype(  u"Hi"s), std::u16string>::value, "" );
-    static_assert ( std::is_same<decltype(  U"Hi"s), std::u32string>::value, "" );
+        ASSERT_SAME_TYPE(decltype(  "Hi"s), std::string);
+        ASSERT_SAME_TYPE(decltype(u8"Hi"s), u8string);
+        ASSERT_SAME_TYPE(decltype( L"Hi"s), std::wstring);
+        ASSERT_SAME_TYPE(decltype( u"Hi"s), std::u16string);
+        ASSERT_SAME_TYPE(decltype( U"Hi"s), std::u32string);
 
         std::string foo;
         std::wstring Lfoo;
         u8string u8foo;
         std::u16string ufoo;
         std::u32string Ufoo;
 
         foo   =   ""s;     assert(  foo.size() == 0);
         u8foo = u8""s;     assert(u8foo.size() == 0);
         Lfoo  =  L""s;     assert( Lfoo.size() == 0);
         ufoo  =  u""s;     assert( ufoo.size() == 0);
         Ufoo  =  U""s;     assert( Ufoo.size() == 0);
 
         foo   =   " "s;    assert(  foo.size() == 1);
         u8foo = u8" "s;    assert(u8foo.size() == 1);
         Lfoo  =  L" "s;    assert( Lfoo.size() == 1);
         ufoo  =  u" "s;    assert( ufoo.size() == 1);
         Ufoo  =  U" "s;    assert( Ufoo.size() == 1);
 
         foo   =   "ABC"s;     assert(  foo ==   "ABC");   assert(  foo == std::string   (  "ABC"));
         u8foo = u8"ABC"s;     assert(u8foo == u8"ABC");   assert(u8foo == u8string      (u8"ABC"));
         Lfoo  =  L"ABC"s;     assert( Lfoo ==  L"ABC");   assert( Lfoo == std::wstring  ( L"ABC"));
         ufoo  =  u"ABC"s;     assert( ufoo ==  u"ABC");   assert( ufoo == std::u16string( u"ABC"));
         Ufoo  =  U"ABC"s;     assert( Ufoo ==  U"ABC");   assert( Ufoo == std::u32string( U"ABC"));
+    }
+    {
+        using namespace std::literals;
+        std::string foo = ""s;
+        assert(foo == std::string());
+    }
+    {
+        using namespace std;
+        std::string foo = ""s;
+        assert(foo == std::string());
+    }
 
     return 0;
 }

libcxx/test/std/strings/basic.string.literals/literal.verify.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
 #include <string>
-#include <cassert>
 
-int main(int, char**)
+void f() {
   {
     using std::string;
-
-    string foo  =   ""s;  // should fail w/conversion operator not found
-
-  return 0;
+    string foo = ""s; // expected-error {{no matching literal operator}}
+  }
+  {
+    std::string foo = ""s; // expected-error {{no matching literal operator}}
+  }
 }

libcxx/test/std/strings/basic.string.literals/literal1.pass.cpp

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// 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
-
-#include <string>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using namespace std::literals;
-
-    std::string foo  =   ""s;
-
-  return 0;
-}

libcxx/test/std/strings/basic.string.literals/literal2.compile.fail.cpp

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// 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
-
-#include <string>
-#include <cassert>
-
-int main(int, char**)
-{
-    std::string foo  =   ""s;  // should fail w/conversion operator not found
-
-  return 0;
-}

libcxx/test/std/strings/basic.string.literals/literal2.pass.cpp

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// 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
-
-#include <string>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using namespace std::literals::string_literals;
-
-    std::string foo  =   ""s;
-
-  return 0;
-}

libcxx/test/std/strings/basic.string.literals/literal3.pass.cpp

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// 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
-
-#include <string>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using namespace std;
-
-    string foo  =   ""s;
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string_view.literals/literal.pass.cpp

 #include "test_macros.h"
 
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     typedef std::u8string_view u8string_view;
 #else
     typedef std::string_view   u8string_view;
 #endif
 
-int main(int, char**)
+int main(int, char**) {
     {
         using namespace std::literals::string_view_literals;
 
-    static_assert ( std::is_same<decltype(   "Hi"sv), std::string_view>::value, "" );
-    static_assert ( std::is_same<decltype( u8"Hi"sv), u8string_view>::value, "" );
-    static_assert ( std::is_same<decltype(  L"Hi"sv), std::wstring_view>::value, "" );
-    static_assert ( std::is_same<decltype(  u"Hi"sv), std::u16string_view>::value, "" );
-    static_assert ( std::is_same<decltype(  U"Hi"sv), std::u32string_view>::value, "" );
+        ASSERT_SAME_TYPE(decltype(  "Hi"sv), std::string_view);
+        ASSERT_SAME_TYPE(decltype(u8"Hi"sv), u8string_view);
+        ASSERT_SAME_TYPE(decltype( L"Hi"sv), std::wstring_view);
+        ASSERT_SAME_TYPE(decltype( u"Hi"sv), std::u16string_view);
+        ASSERT_SAME_TYPE(decltype( U"Hi"sv), std::u32string_view);
 
         std::string_view foo;
         std::wstring_view Lfoo;
         u8string_view u8foo;
         std::u16string_view ufoo;
         std::u32string_view Ufoo;
 
-
         foo  =    ""sv;     assert(  foo.size() == 0);
         u8foo = u8""sv;     assert(u8foo.size() == 0);
         Lfoo  =  L""sv;     assert( Lfoo.size() == 0);
         ufoo  =  u""sv;     assert( ufoo.size() == 0);
         Ufoo  =  U""sv;     assert( Ufoo.size() == 0);
 
         foo   =   " "sv;    assert(  foo.size() == 1);
         u8foo = u8" "sv;    assert(u8foo.size() == 1);
         Lfoo  =  L" "sv;    assert( Lfoo.size() == 1);
         ufoo  =  u" "sv;    assert( ufoo.size() == 1);
         Ufoo  =  U" "sv;    assert( Ufoo.size() == 1);
 
         foo   =   "ABC"sv;  assert(  foo ==   "ABC");   assert(  foo == std::string_view   (  "ABC"));
         u8foo = u8"ABC"sv;  assert(u8foo == u8"ABC");   assert(u8foo == u8string_view      (u8"ABC"));
         Lfoo  =  L"ABC"sv;  assert( Lfoo ==  L"ABC");   assert( Lfoo == std::wstring_view  ( L"ABC"));
         ufoo  =  u"ABC"sv;  assert( ufoo ==  u"ABC");   assert( ufoo == std::u16string_view( u"ABC"));
         Ufoo  =  U"ABC"sv;  assert( Ufoo ==  U"ABC");   assert( Ufoo == std::u32string_view( U"ABC"));
 
         static_assert(  "ABC"sv.size() == 3, "");
         static_assert(u8"ABC"sv.size() == 3, "");
         static_assert( L"ABC"sv.size() == 3, "");
         static_assert( u"ABC"sv.size() == 3, "");
         static_assert( U"ABC"sv.size() == 3, "");
 
-    static_assert(noexcept(  "ABC"sv), "");
-    static_assert(noexcept(u8"ABC"sv), "");
-    static_assert(noexcept( L"ABC"sv), "");
-    static_assert(noexcept( u"ABC"sv), "");
-    static_assert(noexcept( U"ABC"sv), "");
+        ASSERT_NOEXCEPT(  "ABC"sv);
+        ASSERT_NOEXCEPT(u8"ABC"sv);
+        ASSERT_NOEXCEPT( L"ABC"sv);
+        ASSERT_NOEXCEPT( u"ABC"sv);
+        ASSERT_NOEXCEPT( U"ABC"sv);
+    }
+    {
+        using namespace std::literals;
+        std::string_view foo = ""sv;
+        assert(foo.length() == 0);
+    }
+    {
+        using namespace std;
+        std::string_view foo = ""sv;
+        assert(foo.length() == 0);
+    }
 
     return 0;
 }

libcxx/test/std/strings/string.view/string_view.literals/literal.verify.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 
 #include <string_view>
-#include <cassert>
 
-int main(int, char**)
+void f() {
   {
     using std::string_view;
-
-    string_view foo  =   ""sv;  // should fail w/conversion operator not found
-
-  return 0;
+    string_view foo = ""sv; // expected-error {{no matching literal operator}}
+  }
+  {
+    std::string_view foo = ""sv; // expected-error {{no matching literal operator}}
+  }
 }

libcxx/test/std/strings/string.view/string_view.literals/literal1.pass.cpp

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// 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
-
-// Note: libc++ supports string_view before C++17, but literals were introduced in C++14
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using namespace std::literals;
-
-    std::string_view foo  =   ""sv;
-    assert(foo.length() == 0);
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string_view.literals/literal2.compile.fail.cpp

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// 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
-
-#include <string_view>
-#include <cassert>
-
-int main(int, char**)
-{
-    std::string_view foo  =   ""sv;  // should fail w/conversion operator not found
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string_view.literals/literal2.pass.cpp

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// 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
-
-// Note: libc++ supports string_view before C++17, but literals were introduced in C++14
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using namespace std::literals::string_view_literals;
-
-    std::string_view foo  =   ""sv;
-    assert(foo.length() == 0);
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string_view.literals/literal3.pass.cpp

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// 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
-
-// Note: libc++ supports string_view before C++17, but literals were introduced in C++14
-
-#include <string_view>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using namespace std;
-
-    string_view foo  =   ""sv;
-    assert(foo.length() == 0);
-
-  return 0;
-}

libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/function.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // function
 
 #include <type_traits>
 #include "test_macros.h"
 
-using namespace std;
-
 class Class {};
 
 enum Enum1 {};
 #if TEST_STD_VER >= 11
 enum class Enum2 : int {};
 #else
 enum Enum2 {};
 #endif

libcxx/test/support/any_helpers.h

 bool isSmallType() {
     return IsSmallObject<Type>::value;
 }
 
 // Assert that an object is empty. If the object used to contain an object
 // of type 'LastType' check that it can no longer be accessed.
 template <class LastType = int>
 void assertEmpty(std::any const& a) {
-    using namespace std;
     assert(!a.has_value());
     RTTI_ASSERT(a.type() == typeid(void));
-    assert(any_cast<LastType const>(&a) == nullptr);
+    assert(std::any_cast<LastType const>(&a) == nullptr);
 }
 
 template <class Type>
 constexpr auto has_value_member(int) -> decltype(std::declval<Type&>().value, true)
 { return true; }
 template <class> constexpr bool has_value_member(long) { return false; }
 
 

 }
 
 
 // Modify the value of a "test type" stored within an any to the specified
 // 'value'.
 template <class Type>
 _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
 void modifyValue(std::any& a, int value) {
-    using namespace std;
-    using namespace std::experimental;
     assert(a.has_value());
     assert(containsType<Type>(a));
-    any_cast<Type&>(a).value = value;
+    std::any_cast<Type&>(a).value = value;
 }
 
 // A test type that will trigger the small object optimization within 'any'.
 template <int Dummy = 0>
 struct small_type
 {
     static int count;
     static int copied;
struct large_tracked_t {
   int dummy[sizeof(std::any) / sizeof(int) + 1];
 };
 
 static_assert(!IsSmallObject<large_tracked_t>::value, "must not be small");
 
 
 template <class Type, class ...Args>
 void assertArgsMatch(std::any const& a) {
-    using namespace std;
-    using namespace std::experimental;
     assert(a.has_value());
     assert(containsType<Type>(a));
-    assert(any_cast<Type const &>(a).arg_types == &makeArgumentID<Args...>());
+    assert(std::any_cast<Type const &>(a).arg_types == &makeArgumentID<Args...>());
 };
 
 
 #endif