maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

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

Differential Revision: https://reviews.llvm.org/D109120
This commit is contained in:
Louis Dionne 2021-09-01 16:52:52 -04:00
parent f37e132263
commit ef2cdfe393
20 changed files with 197 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -6,7 +6,10 @@
//
//===----------------------------------------------------------------------===//
// 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
@ -14,8 +17,6 @@
#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

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

@ -17,18 +17,11 @@
// https://llvm.org/PR16542
#include <map>
#include <tuple>
#include "test_macros.h"
int main(int, char**) {
std::map<std::tuple<int, int>, std::size_t> m;
m[std::make_tuple(2, 3)] = 7;
int main(int, char**)
{
using namespace std;
map<tuple<int,int>, size_t> m;
m[make_tuple(2,3)]=7;
return 0;
return 0;
}

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

@ -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;
}

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

@ -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);

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

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

100
libcxx/test/std/re/re.const/re.matchflag/match_prev_avail.pass.cpp
View File

@ -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;
}

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

@ -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;
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);
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;
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() == 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 = " "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());
}
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;
return 0;
}

14
libcxx/test/std/strings/basic.string.literals/literal1.compile.fail.cpp → libcxx/test/std/strings/basic.string.literals/literal.verify.cpp
View File

@ -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}}
}
}

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

@ -1,24 +0,0 @@
// -*- 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;
}

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

@ -1,20 +0,0 @@
// -*- 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;
}

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

@ -1,24 +0,0 @@
// -*- 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;
}

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

@ -1,24 +0,0 @@
// -*- 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;
}

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

@ -22,52 +22,62 @@
typedef std::string_view u8string_view;
#endif
int main(int, char**)
{
using namespace std::literals::string_view_literals;
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;
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() == 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 = " "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"));
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( "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, "");
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);
}
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), "");
return 0;
return 0;
}

14
libcxx/test/std/strings/string.view/string_view.literals/literal1.compile.fail.cpp → libcxx/test/std/strings/string.view/string_view.literals/literal.verify.cpp
View File

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

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

@ -1,27 +0,0 @@
// -*- 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;
}

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

@ -1,20 +0,0 @@
// -*- 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;
}

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

@ -1,27 +0,0 @@
// -*- 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;
}

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

@ -1,27 +0,0 @@
// -*- 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;
}

2
libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
View File

@ -13,8 +13,6 @@
#include <type_traits>
#include "test_macros.h"
using namespace std;
class Class {};
enum Enum1 {};

11
libcxx/test/support/any_helpers.h
View File

@ -52,10 +52,9 @@ bool isSmallType() {
// 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>
@ -89,11 +88,9 @@ assertContains(std::any const& a, Value 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'.
@ -422,11 +419,9 @@ 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...>());
};