This is an archive of the discontinued LLVM Phabricator instance.

Differential D154227

[libc++] Enables constexpr string tests.
ClosedPublic

Authored by Mordante on Jun 30 2023, 8:41 AM.

Details

Reviewers
philnik
Group Reviewers
Restricted Project
Commits
rG0fa67d44e0ab: [libc++] Enables constexpr string tests.
Summary

These tests were disabled during constant evaluation in D90569. At that
time constexpr string was not implemented. It now is.

Diff Detail

Event Timeline

Mordante created this revision.Jun 30 2023, 8:41 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 30 2023, 8:41 AM
Mordante requested review of this revision.Jun 30 2023, 8:41 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 30 2023, 8:41 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
philnik accepted this revision.Jun 30 2023, 9:41 AM
This revision is now accepted and ready to land.Jun 30 2023, 9:41 AM
Harbormaster completed remote builds in B242443: Diff 536276.Jun 30 2023, 10:08 AM
Closed by commit rG0fa67d44e0ab: [libc++] Enables constexpr string tests. (authored by Mordante). · Explain WhyJul 1 2023, 3:27 AM
This revision was automatically updated to reflect the committed changes.
Mordante added a commit: rG0fa67d44e0ab: [libc++] Enables constexpr string tests..

Revision Contents

PathSize
libcxx/
test/
std/
numerics/
numeric.ops/
accumulate/
20 lines
adjacent.difference/
20 lines
inner.product/
20 lines
partial.sum/
20 lines

Diff 536520

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linestest_use_move()
rvalue_addable arr[100]; rvalue_addable arr[100];
auto res1 = std::accumulate(arr, arr + 100, rvalue_addable()); auto res1 = std::accumulate(arr, arr + 100, rvalue_addable());
auto res2 = std::accumulate(arr, arr + 100, rvalue_addable(), /*predicate=*/rvalue_addable()); auto res2 = std::accumulate(arr, arr + 100, rvalue_addable(), /*predicate=*/rvalue_addable());
assert(res1.correctOperatorUsed); assert(res1.correctOperatorUsed);
assert(res2.correctOperatorUsed); assert(res2.correctOperatorUsed);
} }
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
// C++20 can use string in constexpr evaluation, but both libc++ and MSVC TEST_CONSTEXPR_CXX20 void test_string() {
// don't have the support yet. In these cases omit the constexpr test.
// FIXME Remove constexpr string workaround introduced in D90569
#if TEST_STD_VER > 17 && \
(!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
void
#else
TEST_CONSTEXPR_CXX20 void
#endif
test_string()
{
std::string sa[] = {"a", "b", "c"}; std::string sa[] = {"a", "b", "c"};
assert(std::accumulate(sa, sa + 3, std::string()) == "abc"); assert(std::accumulate(sa, sa + 3, std::string()) == "abc");
assert(std::accumulate(sa, sa + 3, std::string(), std::plus<std::string>()) == "abc"); assert(std::accumulate(sa, sa + 3, std::string(), std::plus<std::string>()) == "abc");
} }
template <class Iter, class T> template <class Iter, class T>
TEST_CONSTEXPR_CXX20 void TEST_CONSTEXPR_CXX20 void
test(Iter first, Iter last, T init, T x) test(Iter first, Iter last, T init, T x)
Show All 24 Linestest()
test<forward_iterator<const int*> >(); test<forward_iterator<const int*> >();
test<bidirectional_iterator<const int*> >(); test<bidirectional_iterator<const int*> >();
test<random_access_iterator<const int*> >(); test<random_access_iterator<const int*> >();
test<const int*>(); test<const int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
test_use_move(); test_use_move();
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
// C++20 can use string in constexpr evaluation, but both libc++ and MSVC
// don't have the support yet. In these cases omit the constexpr test.
// FIXME Remove constexpr string workaround introduced in D90569
#if TEST_STD_VER > 17 && \
(!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
if (!std::is_constant_evaluated())
#endif
test_string(); test_string();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test()); static_assert(test());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linestest_use_move()
std::adjacent_difference(arr, arr + size, res1); std::adjacent_difference(arr, arr + size, res1);
std::adjacent_difference(arr, arr + size, res2, /*predicate=*/rvalue_subtractable()); std::adjacent_difference(arr, arr + size, res2, /*predicate=*/rvalue_subtractable());
// start at 1 because the first element is not moved // start at 1 because the first element is not moved
for (unsigned i = 1; i < size; ++i) assert(res1[i].correctOperatorUsed); for (unsigned i = 1; i < size; ++i) assert(res1[i].correctOperatorUsed);
for (unsigned i = 1; i < size; ++i) assert(res2[i].correctOperatorUsed); for (unsigned i = 1; i < size; ++i) assert(res2[i].correctOperatorUsed);
} }
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
// C++20 can use string in constexpr evaluation, but both libc++ and MSVC TEST_CONSTEXPR_CXX20 void test_string() {
// don't have the support yet. In these cases omit the constexpr test.
// FIXME Remove constexpr string workaround introduced in D90569
#if TEST_STD_VER > 17 && \
(!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
void
#else
TEST_CONSTEXPR_CXX20 void
#endif
test_string()
{
std::string sa[] = {"a", "b", "c"}; std::string sa[] = {"a", "b", "c"};
std::string sr[] = {"a", "ba", "cb"}; std::string sr[] = {"a", "ba", "cb"};
std::string output[3]; std::string output[3];
std::adjacent_difference(sa, sa + 3, output, std::plus<std::string>()); std::adjacent_difference(sa, sa + 3, output, std::plus<std::string>());
for (unsigned i = 0; i < 3; ++i) assert(output[i] == sr[i]); for (unsigned i = 0; i < 3; ++i) assert(output[i] == sr[i]);
} }
template <class InIter, class OutIter> template <class InIter, class OutIter>
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
X x[3] = {X(1), X(2), X(3)}; X x[3] = {X(1), X(2), X(3)};
Y y[3] = {Y(1), Y(2), Y(3)}; Y y[3] = {Y(1), Y(2), Y(3)};
std::adjacent_difference(x, x+3, y, std::minus<X>()); std::adjacent_difference(x, x+3, y, std::minus<X>());
#endif #endif
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
test_use_move(); test_use_move();
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
// C++20 can use string in constexpr evaluation, but both libc++ and MSVC
// don't have the support yet. In these cases omit the constexpr test.
// FIXME Remove constexpr string workaround introduced in D90569
#if TEST_STD_VER > 17 && \
(!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
if (!std::is_constant_evaluated())
#endif
test_string(); test_string();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test()); static_assert(test());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linestest_use_move()
auto res1 = std::inner_product(arr, arr + 100, arr, rvalue_addable()); auto res1 = std::inner_product(arr, arr + 100, arr, rvalue_addable());
auto res2 = std::inner_product(arr, arr + 100, arr, rvalue_addable(), /*predicate=*/rvalue_addable(), do_nothing_op()); auto res2 = std::inner_product(arr, arr + 100, arr, rvalue_addable(), /*predicate=*/rvalue_addable(), do_nothing_op());
assert(res1.correctOperatorUsed); assert(res1.correctOperatorUsed);
assert(res2.correctOperatorUsed); assert(res2.correctOperatorUsed);
} }
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
// C++20 can use string in constexpr evaluation, but both libc++ and MSVC TEST_CONSTEXPR_CXX20 void test_string() {
// don't have the support yet. In these cases omit the constexpr test.
// FIXME Remove constexpr string workaround introduced in D90569
#if TEST_STD_VER > 17 && \
(!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
void
#else
TEST_CONSTEXPR_CXX20 void
#endif
test_string()
{
std::string sa[] = {"a", "b", "c"}; std::string sa[] = {"a", "b", "c"};
assert(std::accumulate(sa, sa + 3, std::string()) == "abc"); assert(std::accumulate(sa, sa + 3, std::string()) == "abc");
assert(std::accumulate(sa, sa + 3, std::string(), std::plus<std::string>()) == "abc"); assert(std::accumulate(sa, sa + 3, std::string(), std::plus<std::string>()) == "abc");
} }
template <class Iter1, class Iter2, class T> template <class Iter1, class Iter2, class T>
TEST_CONSTEXPR_CXX20 void TEST_CONSTEXPR_CXX20 void
test(Iter1 first1, Iter1 last1, Iter2 first2, T init, T x) test(Iter1 first1, Iter1 last1, Iter2 first2, T init, T x)
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linestest()
test<const int*, forward_iterator<const int*> >(); test<const int*, forward_iterator<const int*> >();
test<const int*, bidirectional_iterator<const int*> >(); test<const int*, bidirectional_iterator<const int*> >();
test<const int*, random_access_iterator<const int*> >(); test<const int*, random_access_iterator<const int*> >();
test<const int*, const int*>(); test<const int*, const int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
test_use_move(); test_use_move();
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
// C++20 can use string in constexpr evaluation, but both libc++ and MSVC
// don't have the support yet. In these cases omit the constexpr test.
// FIXME Remove constexpr string workaround introduced in D90569
#if TEST_STD_VER > 17 && \
(!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
if (!std::is_constant_evaluated())
#endif
test_string(); test_string();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test()); static_assert(test());
#endif #endif
return 0; return 0;
} }

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Linestest_use_move()
std::partial_sum(arr, arr + size, res1); std::partial_sum(arr, arr + size, res1);
std::partial_sum(arr, arr + size, res2, /*predicate=*/rvalue_addable()); std::partial_sum(arr, arr + size, res2, /*predicate=*/rvalue_addable());
// start at 1 because the first element is not moved // start at 1 because the first element is not moved
for (unsigned i = 1; i < size; ++i) assert(res1[i].correctOperatorUsed); for (unsigned i = 1; i < size; ++i) assert(res1[i].correctOperatorUsed);
for (unsigned i = 1; i < size; ++i) assert(res2[i].correctOperatorUsed); for (unsigned i = 1; i < size; ++i) assert(res2[i].correctOperatorUsed);
} }
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
// C++20 can use string in constexpr evaluation, but both libc++ and MSVC TEST_CONSTEXPR_CXX20 void test_string() {
// don't have the support yet. In these cases omit the constexpr test.
// FIXME Remove constexpr string workaround introduced in D90569
#if TEST_STD_VER > 17 && \
(!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
void
#else
TEST_CONSTEXPR_CXX20 void
#endif
test_string()
{
std::string sa[] = {"a", "b", "c"}; std::string sa[] = {"a", "b", "c"};
std::string sr[] = {"a", "ba", "cb"}; std::string sr[] = {"a", "ba", "cb"};
std::string output[3]; std::string output[3];
std::adjacent_difference(sa, sa + 3, output, std::plus<std::string>()); std::adjacent_difference(sa, sa + 3, output, std::plus<std::string>());
for (unsigned i = 0; i < 3; ++i) assert(output[i] == sr[i]); for (unsigned i = 0; i < 3; ++i) assert(output[i] == sr[i]);
} }
template <class InIter, class OutIter> template <class InIter, class OutIter>
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linestest()
test<const int*, forward_iterator<int*> >(); test<const int*, forward_iterator<int*> >();
test<const int*, bidirectional_iterator<int*> >(); test<const int*, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<int*> >(); test<const int*, random_access_iterator<int*> >();
test<const int*, int*>(); test<const int*, int*>();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
test_use_move(); test_use_move();
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
// C++20 can use string in constexpr evaluation, but both libc++ and MSVC
// don't have the support yet. In these cases omit the constexpr test.
// FIXME Remove constexpr string workaround introduced in D90569
#if TEST_STD_VER > 17 && \
(!defined(__cpp_lib_constexpr_string) || __cpp_lib_constexpr_string < 201907L)
if (!std::is_constant_evaluated())
#endif
test_string(); test_string();
return true; return true;
} }
int main(int, char**) int main(int, char**)
{ {
test(); test();
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
static_assert(test()); static_assert(test());
#endif #endif
return 0; return 0;
} }