[libcxx] [test] Use LIBCPP_ASSERT for libc++-specific checks

[jwakely]

Summary

This makes it a little easier to reuse the libc++ tests for another
std::lib (specifically libstdc++).

The regex_error::what() strings are different in other
implementations, so should be tested with LIBCPP_ASSERT so that those
checks are skipped for other implementations.

The value of ECMAScript constant is non-zero in other implementations,
and conditionally for libc++, so adjust the preprocessor condition for
that too.

[jwakely]

libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp

41

An alternative to this would be for me to define _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO in test/support/test_macros.h when libstdc++ is detected.

It seems slightly more correct to check this, rather than have non-libc++ implementations define a macro about the libc++ ABI variant, but I'll do it whichever way you like.

[philnik]

libcxx/test/std/re/re.badexp/regex_error.pass.cpp

116–119

You can use LIBCPP_ASSERT for all of these instead.

libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp

41–46

If this isn't portable this should be a LIBCPP_ASSERT IMO.

[jwakely]

libcxx/test/std/re/re.badexp/regex_error.pass.cpp

116–119

Ah yes, that would be better.

libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp

41–46

How would that work? The standard guarantees that it's non-zero, and libstdc++ implements that. Libc++ makes it zero by default, or non-zero with a non-default ABI setting. So it's portable that the constant exists, but whether it's non-zero is not portable even among different builds of libc++.

[jwakely]

Update to use LIBCPP_ASSERT as suggested by @philnik

[ldionne]

LGTM with a suggestion. Thanks for catching those Jonathan!

libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp

41–42

Would you mind reversing those conditions? For some reason, I find #if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO) to be much easier to understand.

[jwakely]

Reverse conditions in test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp as requested by Louis.

[philnik]

LGTM.

libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp

41–46

Oh, sorry. I didn't realize that there is a standard behaviour and libc++ just gets it wrong.

[Mordante]

Nice cleanup, LGTM!

[ldionne]

@jwakely Would you like us to land this for you?

[jwakely]

Yes please, I don't have commit access.

[philnik]

@jwakely Could you provide "You Name" <[e-mail]> for attribution?

[jwakely]

Jonathan Wakely <[e-mail]>

(Shouldn't phabricator preserve that when a Git commit containing that info is uploaded as the diff?)

[philnik]

In D122574#3455652, @jwakely wrote:

Jonathan Wakely <[e-mail]>

(Shouldn't phabricator preserve that when a Git commit containing that info is uploaded as the diff?)

It normally does, but it looks like phabricator didn't store any commits in this case. Did you upload the patch through arc diff?

libcxx/test/std/re/re.badexp/regex_error.pass.cpp

 #include <cassert>
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::regex_error e(std::regex_constants::error_collate);
         assert(e.code() == std::regex_constants::error_collate);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The expression contained an invalid collating element name."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_ctype);
         assert(e.code() == std::regex_constants::error_ctype);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The expression contained an invalid character class name."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_escape);
         assert(e.code() == std::regex_constants::error_escape);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The expression contained an invalid escaped character, or a "
                "trailing escape."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_backref);
         assert(e.code() == std::regex_constants::error_backref);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The expression contained an invalid back reference."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_brack);
         assert(e.code() == std::regex_constants::error_brack);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The expression contained mismatched [ and ]."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_paren);
         assert(e.code() == std::regex_constants::error_paren);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The expression contained mismatched ( and )."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_brace);
         assert(e.code() == std::regex_constants::error_brace);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The expression contained mismatched { and }."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_badbrace);
         assert(e.code() == std::regex_constants::error_badbrace);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The expression contained an invalid range in a {} expression."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_range);
         assert(e.code() == std::regex_constants::error_range);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The expression contained an invalid character range, "
                "such as [b-a] in most encodings."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_space);
         assert(e.code() == std::regex_constants::error_space);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("There was insufficient memory to convert the expression into "
                "a finite state machine."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_badrepeat);
         assert(e.code() == std::regex_constants::error_badrepeat);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("One of *?+{ was not preceded by a valid regular expression."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_complexity);
         assert(e.code() == std::regex_constants::error_complexity);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("The complexity of an attempted match against a regular "
                "expression exceeded a pre-set level."));
+#endif
     }
     {
         std::regex_error e(std::regex_constants::error_stack);
         assert(e.code() == std::regex_constants::error_stack);
+#ifdef _LIBCPP_VERSION
         assert(e.what() == std::string("There was insufficient memory to determine whether the regular "
                "expression could match the specified character sequence."));
+#endif
     }
 
   return 0;
 }

libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp

 #include "test_macros.h"
 
 int main(int, char**)
 {
     assert(std::regex_constants::icase != 0);
     assert(std::regex_constants::nosubs != 0);
     assert(std::regex_constants::optimize != 0);
     assert(std::regex_constants::collate != 0);
-#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO  // https://llvm.org/PR35967
+#if defined _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO || !defined _LIBCPP_VERSION
+    // https://llvm.org/PR35967
     assert(std::regex_constants::ECMAScript != 0);
 #else
     assert(std::regex_constants::ECMAScript == 0);
 #endif
     assert(std::regex_constants::basic != 0);
     assert(std::regex_constants::extended != 0);
     assert(std::regex_constants::awk != 0);
     assert(std::regex_constants::grep != 0);
     assert(std::regex_constants::egrep != 0);
     assert(std::regex_constants::multiline != 0);
 
     assert((std::regex_constants::icase & std::regex_constants::nosubs) == 0);