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

Differential Revision: https://reviews.llvm.org/D109120

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

@@ -6,16 +6,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-// 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));
@@ -24,4 +25,4 @@ int main(int, char**) {
   return 0;
 }
 
-using namespace std;
+using namespace std; // on purpose

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

@@ -17,18 +17,11 @@
 // 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;
+    return 0;
 }

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

@@ -18,22 +18,17 @@
 
 // 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;
+    return 0;
 }

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

@@ -20,27 +20,41 @@
 #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;
+    path p1(value1);
+    path p2(value2);
+    fs::path::string_type ps1 = p1.native();
+    fs::path::string_type ps2 = p2.native();
+
+    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);

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

@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
-// <chrono>
+// <complex>
 
 #include <complex>
 #include <type_traits>

libcxx/test/std/re/re.const/re.matchflag/match_prev_avail.pass.cpp

@@ -13,70 +13,72 @@
 //     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")));
+  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(
-      !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(!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(regex_search(Start, End, regex("^cd"),
-                      regex_constants::match_prev_avail));
+  assert(std::regex_search(Start, End, std::regex("^cd"),
+            std::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));
+  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

@@ -20,40 +20,50 @@
     typedef std::string   u8string;
 #endif
 
+int main(int, char**) {
+    {
+        using namespace std::literals::string_literals;
 
-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, "" );
-
-    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"));
-
-  return 0;
+        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/literal1.compile.fail.cpp → libcxx/test/std/strings/basic.string.literals/literal.verify.cpp

@@ -10,13 +10,13 @@
 // 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}}
+  }
 }