//
//===----------------------------------------------------------------------===//
-// 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));
return 0;
}
-using namespace std;
+using namespace std; // on purpose
// 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;
}
// 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;
}
#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);
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11
-// <chrono>
+// <complex>
#include <complex>
#include <type_traits>
// 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;
}
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;
}
// 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}}
+ }
}
+++ /dev/null
-// -*- 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;
-}
+++ /dev/null
-// -*- 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;
-}
+++ /dev/null
-// -*- 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;
-}
+++ /dev/null
-// -*- 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;
-}
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;
}
// 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}}
+ }
}
+++ /dev/null
-// -*- 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;
-}
+++ /dev/null
-// -*- 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;
-}
+++ /dev/null
-// -*- 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;
-}
+++ /dev/null
-// -*- 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;
-}
#include <type_traits>
#include "test_macros.h"
-using namespace std;
-
class Class {};
enum Enum1 {};
// 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>
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 <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...>());
};