This is an archive of the discontinued LLVM Phabricator instance.

Differential D132626

[libc++][test] Use TEST_HAS_NO_CHAR8_T to simplify #ifdefs. NFCI.
ClosedPublic

Authored by jloser on Aug 24 2022, 5:59 PM.

Details

Reviewers
philnik
Mordante
var-const
ldionne
Group Reviewers
Restricted Project
Commits
rGeb1ceb17ae97: [libc++][test] Use TEST_HAS_NO_CHAR8_T to simplify #ifdefs. NFCI.
Summary

Many tests in libcxx/test/std/strings use `#if defined(cpp_lib_char8_t) &&
cpp_lib_char8_t >= 201811L` which can be replaced with the more terse `#ifndef
TEST_HAS_NO_CHAR8_T`.

Diff Detail

Event Timeline

jloser created this revision.Aug 24 2022, 5:59 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 24 2022, 5:59 PM
jloser requested review of this revision.Aug 24 2022, 5:59 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 24 2022, 5:59 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B183279: Diff 455443.Aug 24 2022, 9:11 PM
Mordante added a comment.Aug 25 2022, 9:11 AM

Interesting I thought I had already done this :-/
Thanks for the cleanup! LGTM!

Mordante accepted this revision.Aug 25 2022, 9:12 AM

(Or you select the accept option ;-) )

This revision is now accepted and ready to land.Aug 25 2022, 9:12 AM
Closed by commit rGeb1ceb17ae97: [libc++][test] Use TEST_HAS_NO_CHAR8_T to simplify #ifdefs. NFCI. (authored by jloser). · Explain WhyAug 25 2022, 8:09 PM
This revision was automatically updated to reflect the committed changes.
jloser added a commit: rGeb1ceb17ae97: [libc++][test] Use TEST_HAS_NO_CHAR8_T to simplify #ifdefs. NFCI..

Revision Contents

PathSize
libcxx/
test/
std/
strings/
basic.string.hash/
2 lines
2 lines
basic.string.literals/
2 lines
char.traits/
char.traits.specializations/
char.traits.specializations.char8_t/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
string.classes/
2 lines
string.view/
string.view.hash/
2 lines
2 lines
string.view.capacity/
4 lines
string.view.cons/
4 lines
2 lines
2 lines
string.view.iterators/
10 lines
10 lines
10 lines
10 lines
string_view.literals/
2 lines
2 lines
utilities/
meta/
meta.unary/
meta.unary.cat/
2 lines

Diff 455781

libcxx/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp

Show All 20 Lines
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
{ {
test_hash_enabled_for_type<std::string>(); test_hash_enabled_for_type<std::string>();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test_hash_enabled_for_type<std::wstring>(); test_hash_enabled_for_type<std::wstring>();
#endif #endif
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test_hash_enabled_for_type<std::u8string>(); test_hash_enabled_for_type<std::u8string>();
#endif #endif
test_hash_enabled_for_type<std::u16string>(); test_hash_enabled_for_type<std::u16string>();
test_hash_enabled_for_type<std::u32string>(); test_hash_enabled_for_type<std::u32string>();
} }
return 0; return 0;
} }

libcxx/test/std/strings/basic.string.hash/strings.pass.cpp

Show All 38 Lines#endif
T s1(g1.begin(), g1.end()); T s1(g1.begin(), g1.end());
T s2(g2.begin(), g2.end()); T s2(g2.begin(), g2.end());
assert(h(s1) != h(s2)); assert(h(s1) != h(s2));
} }
int main(int, char**) int main(int, char**)
{ {
test<std::string>(); test<std::string>();
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test<std::u8string>(); test<std::u8string>();
#endif #endif
test<std::u16string>(); test<std::u16string>();
test<std::u32string>(); test<std::u32string>();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<std::wstring>(); test<std::wstring>();
#endif #endif
return 0; return 0;
} }

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

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
typedef std::u8string u8string; typedef std::u8string u8string;
#else #else
typedef std::string u8string; typedef std::string u8string;
#endif #endif
int main(int, char**) { int main(int, char**) {
{ {
using namespace std::literals::string_literals; using namespace std::literals::string_literals;
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp

Show All 11 Lines
// static constexpr void assign(char_type& c1, const char_type& c2); // static constexpr void assign(char_type& c1, const char_type& c2);
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
constexpr bool test_constexpr() constexpr bool test_constexpr()
{ {
char8_t c = u'1'; char8_t c = u'1';
std::char_traits<char8_t>::assign(c, u'a'); std::char_traits<char8_t>::assign(c, u'a');
return c == u'a'; return c == u'a';
} }
int main(int, char**) int main(int, char**)
Show All 13 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp

Show All 15 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
char8_t s2[3] = {0}; char8_t s2[3] = {0};
assert(std::char_traits<char8_t>::assign(s2, 3, char8_t(5)) == s2); assert(std::char_traits<char8_t>::assign(s2, 3, char8_t(5)) == s2);
assert(s2[0] == char8_t(5)); assert(s2[0] == char8_t(5));
assert(s2[1] == char8_t(5)); assert(s2[1] == char8_t(5));
assert(s2[2] == char8_t(5)); assert(s2[2] == char8_t(5));
assert(std::char_traits<char8_t>::assign(NULL, 0, char8_t(5)) == NULL); assert(std::char_traits<char8_t>::assign(NULL, 0, char8_t(5)) == NULL);
#endif #endif
Show All 13 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp

Show All 12 Lines
// static constexpr int compare(const char_type* s1, const char_type* s2, size_t n); // static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
constexpr bool test_constexpr() constexpr bool test_constexpr()
{ {
return std::char_traits<char8_t>::compare(u8"123", u8"223", 3) < 0 return std::char_traits<char8_t>::compare(u8"123", u8"223", 3) < 0
&& std::char_traits<char8_t>::compare(u8"223", u8"123", 3) > 0 && std::char_traits<char8_t>::compare(u8"223", u8"123", 3) > 0
&& std::char_traits<char8_t>::compare(u8"123", u8"123", 3) == 0; && std::char_traits<char8_t>::compare(u8"123", u8"123", 3) == 0;
} }
Show All 31 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp

Show All 15 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
char8_t s1[] = {1, 2, 3}; char8_t s1[] = {1, 2, 3};
char8_t s2[3] = {0}; char8_t s2[3] = {0};
assert(std::char_traits<char8_t>::copy(s2, s1, 3) == s2); assert(std::char_traits<char8_t>::copy(s2, s1, 3) == s2);
assert(s2[0] == char8_t(1)); assert(s2[0] == char8_t(1));
assert(s2[1] == char8_t(2)); assert(s2[1] == char8_t(2));
assert(s2[2] == char8_t(3)); assert(s2[2] == char8_t(3));
assert(std::char_traits<char8_t>::copy(NULL, s1, 0) == NULL); assert(std::char_traits<char8_t>::copy(NULL, s1, 0) == NULL);
assert(std::char_traits<char8_t>::copy(s1, NULL, 0) == s1); assert(std::char_traits<char8_t>::copy(s1, NULL, 0) == s1);
Show All 15 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp

Show All 14 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
std::char_traits<char8_t>::int_type i = std::char_traits<char8_t>::eof(); std::char_traits<char8_t>::int_type i = std::char_traits<char8_t>::eof();
((void)i); // Prevent unused warning ((void)i); // Prevent unused warning
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp

Show All 14 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
assert( std::char_traits<char8_t>::eq(u8'a', u8'a')); assert( std::char_traits<char8_t>::eq(u8'a', u8'a'));
assert(!std::char_traits<char8_t>::eq(u8'a', u8'A')); assert(!std::char_traits<char8_t>::eq(u8'a', u8'A'));
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp

Show All 14 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
assert( std::char_traits<char8_t>::eq_int_type(u8'a', u8'a')); assert( std::char_traits<char8_t>::eq_int_type(u8'a', u8'a'));
assert(!std::char_traits<char8_t>::eq_int_type(u8'a', u8'A')); assert(!std::char_traits<char8_t>::eq_int_type(u8'a', u8'A'));
assert(!std::char_traits<char8_t>::eq_int_type(std::char_traits<char8_t>::eof(), u8'A')); assert(!std::char_traits<char8_t>::eq_int_type(std::char_traits<char8_t>::eof(), u8'A'));
assert( std::char_traits<char8_t>::eq_int_type(std::char_traits<char8_t>::eof(), assert( std::char_traits<char8_t>::eq_int_type(std::char_traits<char8_t>::eof(),
std::char_traits<char8_t>::eof())); std::char_traits<char8_t>::eof()));
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp

Show All 12 Lines
// static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a); // static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a);
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
constexpr bool test_constexpr() constexpr bool test_constexpr()
{ {
constexpr const char8_t *p = u8"123"; constexpr const char8_t *p = u8"123";
return std::char_traits<char8_t>::find(p, 3, u8'1') == p return std::char_traits<char8_t>::find(p, 3, u8'1') == p
&& std::char_traits<char8_t>::find(p, 3, u8'2') == p + 1 && std::char_traits<char8_t>::find(p, 3, u8'2') == p + 1
&& std::char_traits<char8_t>::find(p, 3, u8'3') == p + 2 && std::char_traits<char8_t>::find(p, 3, u8'3') == p + 2
&& std::char_traits<char8_t>::find(p, 3, u8'4') == nullptr; && std::char_traits<char8_t>::find(p, 3, u8'4') == nullptr;
} }
Show All 19 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp

Show All 12 Lines
// static constexpr size_t length(const char_type* s); // static constexpr size_t length(const char_type* s);
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
constexpr bool test_constexpr() constexpr bool test_constexpr()
{ {
return std::char_traits<char8_t>::length(u8"") == 0 return std::char_traits<char8_t>::length(u8"") == 0
&& std::char_traits<char8_t>::length(u8"abcd") == 4; && std::char_traits<char8_t>::length(u8"abcd") == 4;
} }
int main(int, char**) int main(int, char**)
{ {
Show All 14 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp

Show All 14 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
assert(!std::char_traits<char8_t>::lt(u8'a', u8'a')); assert(!std::char_traits<char8_t>::lt(u8'a', u8'a'));
assert( std::char_traits<char8_t>::lt(u8'A', u8'a')); assert( std::char_traits<char8_t>::lt(u8'A', u8'a'));
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp

Show All 15 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
TEST_CONSTEXPR_CXX20 bool test() TEST_CONSTEXPR_CXX20 bool test()
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
char8_t s1[] = {1, 2, 3}; char8_t s1[] = {1, 2, 3};
assert(std::char_traits<char8_t>::move(s1, s1+1, 2) == s1); assert(std::char_traits<char8_t>::move(s1, s1+1, 2) == s1);
assert(s1[0] == char8_t(2)); assert(s1[0] == char8_t(2));
assert(s1[1] == char8_t(3)); assert(s1[1] == char8_t(3));
assert(s1[2] == char8_t(3)); assert(s1[2] == char8_t(3));
s1[2] = char8_t(0); s1[2] = char8_t(0);
assert(std::char_traits<char8_t>::move(s1+1, s1, 2) == s1+1); assert(std::char_traits<char8_t>::move(s1+1, s1, 2) == s1+1);
assert(s1[0] == char8_t(2)); assert(s1[0] == char8_t(2));
Show All 19 Lines

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp

Show All 14 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
assert(std::char_traits<char8_t>::not_eof(u8'a') == u8'a'); assert(std::char_traits<char8_t>::not_eof(u8'a') == u8'a');
assert(std::char_traits<char8_t>::not_eof(u8'A') == u8'A'); assert(std::char_traits<char8_t>::not_eof(u8'A') == u8'A');
assert(std::char_traits<char8_t>::not_eof(0) == 0); assert(std::char_traits<char8_t>::not_eof(0) == 0);
assert(std::char_traits<char8_t>::not_eof(std::char_traits<char8_t>::eof()) != assert(std::char_traits<char8_t>::not_eof(std::char_traits<char8_t>::eof()) !=
std::char_traits<char8_t>::eof()); std::char_traits<char8_t>::eof());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp

Show All 14 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
assert(std::char_traits<char8_t>::to_char_type(u8'a') == u8'a'); assert(std::char_traits<char8_t>::to_char_type(u8'a') == u8'a');
assert(std::char_traits<char8_t>::to_char_type(u8'A') == u8'A'); assert(std::char_traits<char8_t>::to_char_type(u8'A') == u8'A');
assert(std::char_traits<char8_t>::to_char_type(0) == 0); assert(std::char_traits<char8_t>::to_char_type(0) == 0);
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp

Show All 14 Lines
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
assert(std::char_traits<char8_t>::to_int_type(u8'a') == u8'a'); assert(std::char_traits<char8_t>::to_int_type(u8'a') == u8'a');
assert(std::char_traits<char8_t>::to_int_type(u8'A') == u8'A'); assert(std::char_traits<char8_t>::to_int_type(u8'A') == u8'A');
assert(std::char_traits<char8_t>::to_int_type(0) == 0); assert(std::char_traits<char8_t>::to_int_type(0) == 0);
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp

Show All 20 Lines
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <cstdint> #include <cstdint>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
static_assert((std::is_same<std::char_traits<char8_t>::char_type, char8_t>::value), ""); static_assert((std::is_same<std::char_traits<char8_t>::char_type, char8_t>::value), "");
static_assert((std::is_same<std::char_traits<char8_t>::int_type, unsigned int>::value), ""); static_assert((std::is_same<std::char_traits<char8_t>::int_type, unsigned int>::value), "");
static_assert((std::is_same<std::char_traits<char8_t>::off_type, std::streamoff>::value), ""); static_assert((std::is_same<std::char_traits<char8_t>::off_type, std::streamoff>::value), "");
static_assert((std::is_same<std::char_traits<char8_t>::pos_type, std::u8streampos>::value), ""); static_assert((std::is_same<std::char_traits<char8_t>::pos_type, std::u8streampos>::value), "");
static_assert((std::is_same<std::char_traits<char8_t>::state_type, std::mbstate_t>::value), ""); static_assert((std::is_same<std::char_traits<char8_t>::state_type, std::mbstate_t>::value), "");
static_assert(std::is_same_v<std::char_traits<char8_t>::comparison_category, std::strong_ordering>); static_assert(std::is_same_v<std::char_traits<char8_t>::comparison_category, std::strong_ordering>);
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/string.classes/typedefs.compile.pass.cpp

Show All 20 Lines
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
static_assert((std::is_same<std::string, std::basic_string<char> >::value), ""); static_assert((std::is_same<std::string, std::basic_string<char> >::value), "");
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
static_assert((std::is_same<std::wstring, std::basic_string<wchar_t> >::value), ""); static_assert((std::is_same<std::wstring, std::basic_string<wchar_t> >::value), "");
#endif #endif
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
static_assert((std::is_same<std::u8string, std::basic_string<char8_t> >::value), ""); static_assert((std::is_same<std::u8string, std::basic_string<char8_t> >::value), "");
#endif #endif
static_assert((std::is_same<std::u16string, std::basic_string<char16_t> >::value), ""); static_assert((std::is_same<std::u16string, std::basic_string<char16_t> >::value), "");
static_assert((std::is_same<std::u32string, std::basic_string<char32_t> >::value), ""); static_assert((std::is_same<std::u32string, std::basic_string<char32_t> >::value), "");

libcxx/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp

Show All 21 Lines
int main(int, char**) { int main(int, char**) {
test_library_hash_specializations_available(); test_library_hash_specializations_available();
{ {
test_hash_enabled_for_type<std::string_view>(); test_hash_enabled_for_type<std::string_view>();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test_hash_enabled_for_type<std::wstring_view>(); test_hash_enabled_for_type<std::wstring_view>();
#endif #endif
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test_hash_enabled_for_type<std::u8string_view>(); test_hash_enabled_for_type<std::u8string_view>();
#endif #endif
test_hash_enabled_for_type<std::u16string_view>(); test_hash_enabled_for_type<std::u16string_view>();
test_hash_enabled_for_type<std::u32string_view>(); test_hash_enabled_for_type<std::u32string_view>();
} }
return 0; return 0;
} }

libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines#endif
assert(h(s1) != h(s2)); assert(h(s1) != h(s2));
assert(sh(ss1) == h(s1)); assert(sh(ss1) == h(s1));
assert(sh(ss2) == h(s2)); assert(sh(ss2) == h(s2));
} }
int main(int, char**) int main(int, char**)
{ {
test<std::string_view>(); test<std::string_view>();
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test<std::u8string_view>(); test<std::u8string_view>();
#endif #endif
test<std::u16string_view>(); test<std::u16string_view>();
test<std::u32string_view>(); test<std::u32string_view>();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<std::wstring_view>(); test<std::wstring_view>();
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines// make sure we pick up std::size, too!
assert ( sv1.size() == std::size(sv1)); assert ( sv1.size() == std::size(sv1));
assert ( sv1.empty() == std::empty(sv1)); assert ( sv1.empty() == std::empty(sv1));
#endif #endif
} }
} }
int main(int, char**) { int main(int, char**) {
test1<std::string_view> (); test1<std::string_view> ();
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test1<std::u8string_view> (); test1<std::u8string_view> ();
#endif #endif
test1<std::u16string_view> (); test1<std::u16string_view> ();
test1<std::u32string_view> (); test1<std::u32string_view> ();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test1<std::wstring_view> (); test1<std::wstring_view> ();
#endif #endif
test2 ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 ); test2 ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 );
test2 ( "ABCDE", 5 ); test2 ( "ABCDE", 5 );
test2 ( "a", 1 ); test2 ( "a", 1 );
test2 ( "", 0 ); test2 ( "", 0 );
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test2 ( L"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 ); test2 ( L"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 );
test2 ( L"ABCDE", 5 ); test2 ( L"ABCDE", 5 );
test2 ( L"a", 1 ); test2 ( L"a", 1 );
test2 ( L"", 0 ); test2 ( L"", 0 );
#endif #endif
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test2 ( u8"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 ); test2 ( u8"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 );
test2 ( u8"ABCDE", 5 ); test2 ( u8"ABCDE", 5 );
test2 ( u8"a", 1 ); test2 ( u8"a", 1 );
test2 ( u8"", 0 ); test2 ( u8"", 0 );
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test2 ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 ); test2 ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE", 105 );
Show All 12 Lines

libcxx/test/std/strings/string.view/string.view.cons/assign.pass.cpp

Show All 27 Lines
// We can't just say "sv0 == sv1" here because string_view::compare // We can't just say "sv0 == sv1" here because string_view::compare
// isn't constexpr until C++17, and we want to support back to C++14 // isn't constexpr until C++17, and we want to support back to C++14
return sv0.size() == sv1.size() && sv0.data() == sv1.data(); return sv0.size() == sv1.size() && sv0.data() == sv1.data();
} }
int main(int, char**) { int main(int, char**) {
assert( test<std::string_view> ( "1234")); assert( test<std::string_view> ( "1234"));
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
assert( test<std::u8string_view> (u8"1234")); assert( test<std::u8string_view> (u8"1234"));
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
assert( test<std::u16string_view> ( u"1234")); assert( test<std::u16string_view> ( u"1234"));
assert( test<std::u32string_view> ( U"1234")); assert( test<std::u32string_view> ( U"1234"));
#endif #endif
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
assert( test<std::wstring_view> ( L"1234")); assert( test<std::wstring_view> ( L"1234"));
#endif #endif
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
static_assert( test<std::string_view> ({ "abc", 3}), ""); static_assert( test<std::string_view> ({ "abc", 3}), "");
# if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
static_assert( test<std::u8string_view> ({u8"abc", 3}), ""); static_assert( test<std::u8string_view> ({u8"abc", 3}), "");
# endif # endif
static_assert( test<std::u16string_view> ({ u"abc", 3}), ""); static_assert( test<std::u16string_view> ({ u"abc", 3}), "");
static_assert( test<std::u32string_view> ({ U"abc", 3}), ""); static_assert( test<std::u32string_view> ({ U"abc", 3}), "");
# ifndef TEST_HAS_NO_WIDE_CHARACTERS # ifndef TEST_HAS_NO_WIDE_CHARACTERS
static_assert( test<std::wstring_view> ({ L"abc", 3}), ""); static_assert( test<std::wstring_view> ({ L"abc", 3}), "");
# endif # endif
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/string.view/string.view.cons/default.pass.cpp

Show All 33 Lines#endif
assert ( sv1.size() == 0 ); assert ( sv1.size() == 0 );
assert ( sv1.empty()); assert ( sv1.empty());
} }
} }
int main(int, char**) { int main(int, char**) {
test<std::string_view> (); test<std::string_view> ();
test<std::u16string_view> (); test<std::u16string_view> ();
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test<std::u8string_view> (); test<std::u8string_view> ();
#endif #endif
test<std::u32string_view> (); test<std::u32string_view> ();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<std::wstring_view> (); test<std::wstring_view> ();
#endif #endif
return 0; return 0;
} }

libcxx/test/std/strings/string.view/string.view.cons/from_string.pass.cpp

Show All 37 Linesint main(int, char**) {
test ( std::string() ); test ( std::string() );
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test ( std::wstring(L"QBCDE") ); test ( std::wstring(L"QBCDE") );
test ( std::wstring(L"") ); test ( std::wstring(L"") );
test ( std::wstring() ); test ( std::wstring() );
#endif #endif
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test ( std::u8string{u8"QBCDE"} ); test ( std::u8string{u8"QBCDE"} );
test ( std::u8string{u8""} ); test ( std::u8string{u8""} );
test ( std::u8string{} ); test ( std::u8string{} );
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test ( std::u16string{u"QBCDE"} ); test ( std::u16string{u"QBCDE"} );
test ( std::u16string{u""} ); test ( std::u16string{u""} );
Show All 14 Lines

libcxx/test/std/strings/string.view/string.view.iterators/begin.pass.cpp

Show All 38 Linestest(S s)
assert( b == cb2); assert( b == cb2);
assert(cb1 == cb2); assert(cb1 == cb2);
} }
int main(int, char**) int main(int, char**)
{ {
typedef std::string_view string_view; typedef std::string_view string_view;
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
typedef std::u8string_view u8string_view; typedef std::u8string_view u8string_view;
#endif #endif
typedef std::u16string_view u16string_view; typedef std::u16string_view u16string_view;
typedef std::u32string_view u32string_view; typedef std::u32string_view u32string_view;
test(string_view ()); test(string_view ());
test(u16string_view()); test(u16string_view());
test(u32string_view()); test(u32string_view());
test(string_view ( "123")); test(string_view ( "123"));
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test(u8string_view{u8"123"}); test(u8string_view{u8"123"});
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test(u16string_view{u"123"}); test(u16string_view{u"123"});
test(u32string_view{U"123"}); test(u32string_view{U"123"});
#endif #endif
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
typedef std::wstring_view wstring_view; typedef std::wstring_view wstring_view;
test(wstring_view ()); test(wstring_view ());
test(wstring_view (L"123")); test(wstring_view (L"123"));
#endif #endif
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr string_view sv { "123", 3 }; constexpr string_view sv { "123", 3 };
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
constexpr u8string_view u8sv {u8"123", 3 }; constexpr u8string_view u8sv {u8"123", 3 };
#endif #endif
constexpr u16string_view u16sv {u"123", 3 }; constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 }; constexpr u32string_view u32sv {U"123", 3 };
static_assert ( *sv.begin() == sv[0], "" ); static_assert ( *sv.begin() == sv[0], "" );
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
static_assert ( *u8sv.begin() == u8sv[0], "" ); static_assert ( *u8sv.begin() == u8sv[0], "" );
#endif #endif
static_assert ( *u16sv.begin() == u16sv[0], "" ); static_assert ( *u16sv.begin() == u16sv[0], "" );
static_assert ( *u32sv.begin() == u32sv[0], "" ); static_assert ( *u32sv.begin() == u32sv[0], "" );
static_assert ( *sv.cbegin() == sv[0], "" ); static_assert ( *sv.cbegin() == sv[0], "" );
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
static_assert ( *u8sv.cbegin() == u8sv[0], "" ); static_assert ( *u8sv.cbegin() == u8sv[0], "" );
#endif #endif
static_assert ( *u16sv.cbegin() == u16sv[0], "" ); static_assert ( *u16sv.cbegin() == u16sv[0], "" );
static_assert ( *u32sv.cbegin() == u32sv[0], "" ); static_assert ( *u32sv.cbegin() == u32sv[0], "" );
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
constexpr wstring_view wsv {L"123", 3 }; constexpr wstring_view wsv {L"123", 3 };
Show All 9 Lines

libcxx/test/std/strings/string.view/string.view.iterators/end.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Linestest(S s)
assert( e == ce2); assert( e == ce2);
assert(ce1 == ce2); assert(ce1 == ce2);
} }
int main(int, char**) int main(int, char**)
{ {
typedef std::string_view string_view; typedef std::string_view string_view;
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
typedef std::u8string_view u8string_view; typedef std::u8string_view u8string_view;
#endif #endif
typedef std::u16string_view u16string_view; typedef std::u16string_view u16string_view;
typedef std::u32string_view u32string_view; typedef std::u32string_view u32string_view;
test(string_view ()); test(string_view ());
test(u16string_view()); test(u16string_view());
test(u32string_view()); test(u32string_view());
test(string_view ( "123")); test(string_view ( "123"));
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test(u8string_view{u8"123"}); test(u8string_view{u8"123"});
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test(u16string_view{u"123"}); test(u16string_view{u"123"});
test(u32string_view{U"123"}); test(u32string_view{U"123"});
#endif #endif
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
typedef std::wstring_view wstring_view; typedef std::wstring_view wstring_view;
test(wstring_view ()); test(wstring_view ());
test(wstring_view (L"123")); test(wstring_view (L"123"));
#endif #endif
#if TEST_STD_VER > 11 #if TEST_STD_VER > 11
{ {
constexpr string_view sv { "123", 3 }; constexpr string_view sv { "123", 3 };
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
constexpr u8string_view u8sv {u8"123", 3 }; constexpr u8string_view u8sv {u8"123", 3 };
#endif #endif
constexpr u16string_view u16sv {u"123", 3 }; constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 }; constexpr u32string_view u32sv {U"123", 3 };
static_assert ( sv.begin() != sv.end(), "" ); static_assert ( sv.begin() != sv.end(), "" );
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
static_assert ( u8sv.begin() != u8sv.end(), "" ); static_assert ( u8sv.begin() != u8sv.end(), "" );
#endif #endif
static_assert ( u16sv.begin() != u16sv.end(), "" ); static_assert ( u16sv.begin() != u16sv.end(), "" );
static_assert ( u32sv.begin() != u32sv.end(), "" ); static_assert ( u32sv.begin() != u32sv.end(), "" );
static_assert ( sv.begin() != sv.cend(), "" ); static_assert ( sv.begin() != sv.cend(), "" );
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
static_assert ( u8sv.begin() != u8sv.cend(), "" ); static_assert ( u8sv.begin() != u8sv.cend(), "" );
#endif #endif
static_assert ( u16sv.begin() != u16sv.cend(), "" ); static_assert ( u16sv.begin() != u16sv.cend(), "" );
static_assert ( u32sv.begin() != u32sv.cend(), "" ); static_assert ( u32sv.begin() != u32sv.cend(), "" );
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
constexpr wstring_view wsv {L"123", 3 }; constexpr wstring_view wsv {L"123", 3 };
Show All 9 Lines

libcxx/test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp

Show All 39 Linestest(S s)
assert( b == cb2); assert( b == cb2);
assert(cb1 == cb2); assert(cb1 == cb2);
} }
int main(int, char**) int main(int, char**)
{ {
typedef std::string_view string_view; typedef std::string_view string_view;
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
typedef std::u8string_view u8string_view; typedef std::u8string_view u8string_view;
#endif #endif
typedef std::u16string_view u16string_view; typedef std::u16string_view u16string_view;
typedef std::u32string_view u32string_view; typedef std::u32string_view u32string_view;
test(string_view ()); test(string_view ());
test(u16string_view()); test(u16string_view());
test(u32string_view()); test(u32string_view());
test(string_view ( "123")); test(string_view ( "123"));
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test(u8string_view{u8"123"}); test(u8string_view{u8"123"});
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test(u16string_view{u"123"}); test(u16string_view{u"123"});
test(u32string_view{U"123"}); test(u32string_view{U"123"});
#endif #endif
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
typedef std::wstring_view wstring_view; typedef std::wstring_view wstring_view;
test(wstring_view ()); test(wstring_view ());
test(wstring_view (L"123")); test(wstring_view (L"123"));
#endif #endif
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
constexpr string_view sv { "123", 3 }; constexpr string_view sv { "123", 3 };
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
constexpr u8string_view u8sv {u8"123", 3 }; constexpr u8string_view u8sv {u8"123", 3 };
#endif #endif
constexpr u16string_view u16sv {u"123", 3 }; constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 }; constexpr u32string_view u32sv {U"123", 3 };
static_assert ( *sv.rbegin() == sv[2], "" ); static_assert ( *sv.rbegin() == sv[2], "" );
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
static_assert ( *u8sv.rbegin() == u8sv[2], "" ); static_assert ( *u8sv.rbegin() == u8sv[2], "" );
#endif #endif
static_assert ( *u16sv.rbegin() == u16sv[2], "" ); static_assert ( *u16sv.rbegin() == u16sv[2], "" );
static_assert ( *u32sv.rbegin() == u32sv[2], "" ); static_assert ( *u32sv.rbegin() == u32sv[2], "" );
static_assert ( *sv.crbegin() == sv[2], "" ); static_assert ( *sv.crbegin() == sv[2], "" );
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
static_assert ( *u8sv.crbegin() == u8sv[2], "" ); static_assert ( *u8sv.crbegin() == u8sv[2], "" );
#endif #endif
static_assert ( *u16sv.crbegin() == u16sv[2], "" ); static_assert ( *u16sv.crbegin() == u16sv[2], "" );
static_assert ( *u32sv.crbegin() == u32sv[2], "" ); static_assert ( *u32sv.crbegin() == u32sv[2], "" );
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
constexpr wstring_view wsv {L"123", 3 }; constexpr wstring_view wsv {L"123", 3 };
Show All 9 Lines

libcxx/test/std/strings/string.view/string.view.iterators/rend.pass.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Linestest(S s)
assert( e == ce2); assert( e == ce2);
assert(ce1 == ce2); assert(ce1 == ce2);
} }
int main(int, char**) int main(int, char**)
{ {
typedef std::string_view string_view; typedef std::string_view string_view;
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
typedef std::u8string_view u8string_view; typedef std::u8string_view u8string_view;
#endif #endif
typedef std::u16string_view u16string_view; typedef std::u16string_view u16string_view;
typedef std::u32string_view u32string_view; typedef std::u32string_view u32string_view;
test(string_view ()); test(string_view ());
test(u16string_view()); test(u16string_view());
test(u32string_view()); test(u32string_view());
test(string_view ( "123")); test(string_view ( "123"));
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test(u8string_view{u8"123"}); test(u8string_view{u8"123"});
#endif #endif
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
test(u16string_view{u"123"}); test(u16string_view{u"123"});
test(u32string_view{U"123"}); test(u32string_view{U"123"});
#endif #endif
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
typedef std::wstring_view wstring_view; typedef std::wstring_view wstring_view;
test(wstring_view ()); test(wstring_view ());
test(wstring_view (L"123")); test(wstring_view (L"123"));
#endif #endif
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
{ {
constexpr string_view sv { "123", 3 }; constexpr string_view sv { "123", 3 };
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
constexpr u8string_view u8sv {u8"123", 3 }; constexpr u8string_view u8sv {u8"123", 3 };
#endif #endif
constexpr u16string_view u16sv {u"123", 3 }; constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 }; constexpr u32string_view u32sv {U"123", 3 };
static_assert ( *--sv.rend() == sv[0], "" ); static_assert ( *--sv.rend() == sv[0], "" );
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
static_assert ( *--u8sv.rend() == u8sv[0], "" ); static_assert ( *--u8sv.rend() == u8sv[0], "" );
#endif #endif
static_assert ( *--u16sv.rend() == u16sv[0], "" ); static_assert ( *--u16sv.rend() == u16sv[0], "" );
static_assert ( *--u32sv.rend() == u32sv[0], "" ); static_assert ( *--u32sv.rend() == u32sv[0], "" );
static_assert ( *--sv.crend() == sv[0], "" ); static_assert ( *--sv.crend() == sv[0], "" );
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L # ifndef TEST_HAS_NO_CHAR8_T
static_assert ( *--u8sv.crend() == u8sv[0], "" ); static_assert ( *--u8sv.crend() == u8sv[0], "" );
#endif #endif
static_assert ( *--u16sv.crend() == u16sv[0], "" ); static_assert ( *--u16sv.crend() == u16sv[0], "" );
static_assert ( *--u32sv.crend() == u32sv[0], "" ); static_assert ( *--u32sv.crend() == u32sv[0], "" );
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
{ {
constexpr wstring_view wsv {L"123", 3 }; constexpr wstring_view wsv {L"123", 3 };
Show All 9 Lines

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

Show All 9 Lines
// UNSUPPORTED: c++03, c++11 // UNSUPPORTED: c++03, c++11
// UNSUPPORTED: !stdlib=libc++ && c++14 // UNSUPPORTED: !stdlib=libc++ && c++14
#include <string_view> #include <string_view>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
typedef std::u8string_view u8string_view; typedef std::u8string_view u8string_view;
#else #else
typedef std::string_view u8string_view; typedef std::string_view u8string_view;
#endif #endif
int main(int, char**) { int main(int, char**) {
{ {
using namespace std::literals::string_view_literals; using namespace std::literals::string_view_literals;
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/test/std/strings/string.view/types.pass.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linestest()
static_assert((std::is_same<typename S::iterator, typename S::const_iterator>::value), ""); static_assert((std::is_same<typename S::iterator, typename S::const_iterator>::value), "");
static_assert((std::is_same<typename S::reverse_iterator, typename S::const_reverse_iterator>::value), ""); static_assert((std::is_same<typename S::reverse_iterator, typename S::const_reverse_iterator>::value), "");
} }
int main(int, char**) int main(int, char**)
{ {
test<std::char_traits<char> >(); test<std::char_traits<char> >();
test<std::char_traits<wchar_t> >(); test<std::char_traits<wchar_t> >();
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test<std::char_traits<char8_t> >(); test<std::char_traits<char8_t> >();
#endif #endif
static_assert((std::is_same<std::basic_string_view<char>::traits_type, static_assert((std::is_same<std::basic_string_view<char>::traits_type,
std::char_traits<char> >::value), ""); std::char_traits<char> >::value), "");
return 0; return 0;
} }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Linesint main(int, char**)
test_is_integral<unsigned int>(); test_is_integral<unsigned int>();
test_is_integral<long>(); test_is_integral<long>();
test_is_integral<unsigned long>(); test_is_integral<unsigned long>();
test_is_integral<bool>(); test_is_integral<bool>();
test_is_integral<char>(); test_is_integral<char>();
test_is_integral<signed char>(); test_is_integral<signed char>();
test_is_integral<unsigned char>(); test_is_integral<unsigned char>();
test_is_integral<wchar_t>(); test_is_integral<wchar_t>();
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L #ifndef TEST_HAS_NO_CHAR8_T
test_is_integral<char8_t>(); test_is_integral<char8_t>();
#endif #endif
test_is_not_integral<std::nullptr_t>(); test_is_not_integral<std::nullptr_t>();
test_is_not_integral<void>(); test_is_not_integral<void>();
test_is_not_integral<int&>(); test_is_not_integral<int&>();
test_is_not_integral<int&&>(); test_is_not_integral<int&&>();
test_is_not_integral<int*>(); test_is_not_integral<int*>();
Show All 15 Lines