[libc++][test] Enable constexpr string comparison tests

[jloser]

Summary

Some tests in string.view.comparison are not enabled due to previous lack of
support for constexpr std::string. Now that it is implemented, we can enable
these tests.

[jloser]

@philnik I'm not sure there's actually anything to do here - do you see anything? We do need the TEST_IS_CONSTANT_EVALUATED check so the test won't run in C++14 or C++17 modes for example. So, I think top of tree is fine as-is, unless I'm missing something.

[philnik]

libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp

10

Pre-existing: These tests should only be enabled for libc++ pre-C++17.

55–56

These tests should be enabled for C++20 constant evaluation. You probably have to add a function or macro like is_cxx20_or_runtime_evaluated().

[jloser]

libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp

10

I don't think so, since we backport string_view all the way back to C++03 as an extension.

[jloser]

Enable the tests for C++20

[philnik]

LGTM assuming CI passes. It would be nice if you could disable the tests for other standard libraries pre-C++17.

libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp

10

Sorry, my comment was a bit unclear: It should only be enabled for libc++ pre-C++17. i.e. not for libstdc++, MSVC STL etc. I'm not 100% sure, but I think // UNSUPPORTED: !stdlib=libc++ && (c++03 || c++11 || c++14) should work.

[jloser]

libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp

10

I see. Yeah, I agree with that. That's a pre-existing thing though and I'd recommend we do that for all of the string_view tests. I'm happy to volunteer to do that as a follow-up if that works for you.

[philnik]

The ranges::transform test timeouts are normal. You can consider the CI passed.

libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp

10

Ok yeah. If they are missing for all tests it should probably be done in a separate PR.

[Mordante]

Nice catch! LGTM! It seems the build errors are time-out and they don't seem to be related to your changes.

libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // template<class charT, class traits>
 //   constexpr bool operator==(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>
 #include <string>
 
for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i == j);
             assert((v[i] == v[j]) == expected);
             assert((v[i].data() == v[j]) == expected);
             assert((v[i] == v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) == v[j]) == expected);
             assert((v[i] == ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED) {
-                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) == v[j]) == expected);
                 assert((v[i] == std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc == abc0def) == false);
     assert((abc == abcdef) == false);
     assert((abc0def == abc) == false);
     assert((abc0def == abcdef) == false);
     assert((abcdef == abc) == false);
     assert((abcdef == abc0def) == false);
 
     assert((abc.data() == abc0def) == false);
     assert((abc0def == abc.data()) == false);
 
-    if (!TEST_IS_CONSTANT_EVALUATED) {
-        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) == abc0def) == false);
         assert((abc0def == std::basic_string<CharT, Traits>(abc)) == false);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/greater.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i > j);
             assert((v[i] > v[j]) == expected);
             assert((v[i].data() > v[j]) == expected);
             assert((v[i] > v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) > v[j]) == expected);
             assert((v[i] > ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED) {
-                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) > v[j]) == expected);
                 assert((v[i] > std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc > abc0def) == false);
     assert((abc > abcdef) == false);
     assert((abc0def > abc) == true);
     assert((abc0def > abcdef) == false);
     assert((abcdef > abc) == true);
     assert((abcdef > abc0def) == true);
 
     assert((abc.data() > abc0def) == false);
     assert((abc0def > abc.data()) == true);
 
-    if (!TEST_IS_CONSTANT_EVALUATED) {
-        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) > abc0def) == false);
         assert((abc0def > std::basic_string<CharT, Traits>(abc)) == true);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/greater_equal.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i >= j);
             assert((v[i] >= v[j]) == expected);
             assert((v[i].data() >= v[j]) == expected);
             assert((v[i] >= v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) >= v[j]) == expected);
             assert((v[i] >= ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED) {
-                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) >= v[j]) == expected);
                 assert((v[i] >= std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc >= abc0def) == false);
     assert((abc >= abcdef) == false);
     assert((abc0def >= abc) == true);
     assert((abc0def >= abcdef) == false);
     assert((abcdef >= abc) == true);
     assert((abcdef >= abc0def) == true);
 
     assert((abc.data() >= abc0def) == false);
     assert((abc0def >= abc.data()) == true);
 
-    if (!TEST_IS_CONSTANT_EVALUATED) {
-        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) >= abc0def) == false);
         assert((abc0def >= std::basic_string<CharT, Traits>(abc)) == true);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/less.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i < j);
             assert((v[i] < v[j]) == expected);
             assert((v[i].data() < v[j]) == expected);
             assert((v[i] < v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) < v[j]) == expected);
             assert((v[i] < ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED) {
-                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) < v[j]) == expected);
                 assert((v[i] < std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc < abc0def) == true);
     assert((abc < abcdef) == true);
     assert((abc0def < abc) == false);
     assert((abc0def < abcdef) == true);
     assert((abcdef < abc) == false);
     assert((abcdef < abc0def) == false);
 
     assert((abc.data() < abc0def) == true);
     assert((abc0def < abc.data()) == false);
 
-    if (!TEST_IS_CONSTANT_EVALUATED) {
-        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) < abc0def) == true);
         assert((abc0def < std::basic_string<CharT, Traits>(abc)) == false);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/less_equal.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i <= j);
             assert((v[i] <= v[j]) == expected);
             assert((v[i].data() <= v[j]) == expected);
             assert((v[i] <= v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) <= v[j]) == expected);
             assert((v[i] <= ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED) {
-                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) <= v[j]) == expected);
                 assert((v[i] <= std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc <= abc0def) == true);
     assert((abc <= abcdef) == true);
     assert((abc0def <= abc) == false);
     assert((abc0def <= abcdef) == true);
     assert((abcdef <= abc) == false);
     assert((abcdef <= abc0def) == false);
 
     assert((abc.data() <= abc0def) == true);
     assert((abc0def <= abc.data()) == false);
 
-    if (!TEST_IS_CONSTANT_EVALUATED) {
-        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) <= abc0def) == true);
         assert((abc0def <= std::basic_string<CharT, Traits>(abc)) == false);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/not_equal.pass.cpp

for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i != j);
             assert((v[i] != v[j]) == expected);
             assert((v[i].data() != v[j]) == expected);
             assert((v[i] != v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) != v[j]) == expected);
             assert((v[i] != ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED) {
-                // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) != v[j]) == expected);
                 assert((v[i] != std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc != abc0def) == true);
     assert((abc != abcdef) == true);
     assert((abc0def != abc) == true);
     assert((abc0def != abcdef) == true);
     assert((abcdef != abc) == true);
     assert((abcdef != abc0def) == true);
 
     assert((abc.data() != abc0def) == true);
     assert((abc0def != abc.data()) == true);
 
-    if (!TEST_IS_CONSTANT_EVALUATED) {
-        // TODO FIXME: once P0980 "Making std::string constexpr" is implemented
+    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) != abc0def) == true);
         assert((abc0def != std::basic_string<CharT, Traits>(abc)) == true);
     }
 
     return true;
 }
 
 int main(int, char**)