[libc++] Remove unnecessary main() function in .compile.pass.cpp and .verify.cpp tests

[ldionne]

Summary

We pretty consistently don't define those cause they are not needed,
and it removes the potential pitfall to think that these tests are
being run. This doesn't touch .compile.fail.cpp tests since those
should be replaced by .verify.cpp tests anyway, and there would be
a lot to fix up.

As a fly-by, I also fixed a bit of formatting, removed a few unused
includes and made some very minor, clearly NFC refactorings such as
in allocator.traits/allocator.traits.members/allocate.verify.cpp where
the old test basically made no sense the way it was written.

[philnik]

LGTM with green CI.

[Mordante]

LGTM, did you also verify the verify and fail tests? If not, then that would be nice as a followup.

[ldionne]

In D146236#4200028, @Mordante wrote:

LGTM, did you also verify the verify and fail tests? If not, then that would be nice as a followup.

I'll do it for .verify.cpp tests too, however .compile.fail.cpp tests should move to .verify and there's a lot of them, so I'd rather tackle that separately (if at all for the time being).

[ldionne]

Also tackle .verify.cpp tests

[ldionne]

The no-exceptions configuration is failing due to a clang bug that Mark is still bisecting AFAIK, so this is green.

libcxx/test/libcxx/diagnostics/nodiscard_extensions.compile.pass.cpp

 #endif
 
 #if TEST_STD_VER > 20
   enum E { Apple, Orange } e = Apple;
   std::to_underlying(e);
 #endif
 }
 
-int main(int, char**) {
+void tests() {
   test_algorithms();
 
   int i = 42;
   test_template_cast_wrappers(i, std::move(i));
   test_nontemplate_cast_wrappers();
-
-  return 0;
 }

libcxx/test/libcxx/ranges/version.compile.pass.cpp

 
 #include <ranges>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_VERSION
 #error _LIBCPP_VERSION not defined
 #endif
-
-// Required for MSVC internal test runner compatibility.
-int main(int, char**) { return 0; }

libcxx/test/libcxx/thread/thread.barrier/version.compile.pass.cpp

 
 #include <barrier>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_VERSION
 #error _LIBCPP_VERSION not defined
 #endif
-
-int main(int, char**)
-{
-  return 0;
-}

libcxx/test/libcxx/thread/thread.latch/version.compile.pass.cpp

 
 #include <latch>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_VERSION
 #error _LIBCPP_VERSION not defined
 #endif
-
-int main(int, char**)
-{
-  return 0;
-}

libcxx/test/libcxx/thread/thread.semaphore/version.compile.pass.cpp

 
 #include <semaphore>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_VERSION
 #error _LIBCPP_VERSION not defined
 #endif
-
-int main(int, char**)
-{
-  return 0;
-}

libcxx/test/libcxx/utilities/format/version.compile.pass.cpp

 
 #include <format>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_VERSION
 #  error _LIBCPP_VERSION not defined
 #endif
-
-// Required for MSVC internal test runner compatibility.
-int main(int, char**) { return 0; }

libcxx/test/std/atomics/atomics.types.generic/standard_layout.compile.pass.cpp

 template <class Tp>
 struct CheckStandardLayout {
   void operator()() const {
     typedef std::atomic<Tp> Atomic;
     static_assert(std::is_standard_layout<Atomic>::value, "");
   }
 };
 
-int main(int, char**) {
+void tests() {
   TestEachIntegralType<CheckStandardLayout>()();
   TestEachFloatingPointType<CheckStandardLayout>()();
   TestEachPointerType<CheckStandardLayout>()();
-
-  return 0;
 }

libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable.compile.pass.cpp

 static_assert(!std::equality_comparable<ne_returns_explicit_bool>);
 static_assert(std::equality_comparable<lt_returns_explicit_bool>);
 static_assert(std::equality_comparable<gt_returns_explicit_bool>);
 static_assert(std::equality_comparable<le_returns_explicit_bool>);
 static_assert(std::equality_comparable<ge_returns_explicit_bool>);
 static_assert(std::equality_comparable<returns_true_type>);
 static_assert(std::equality_comparable<returns_int_ptr>);
 } // namespace types_fit_for_purpose
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp

static_assert(
     !check_equality_comparable_with<one_way_eq, explicit_operators>());
 
 static_assert(check_equality_comparable_with<one_way_ne, one_way_ne>());
 static_assert(
     std::common_reference_with<one_way_ne const&, explicit_operators const&>);
 static_assert(
     !check_equality_comparable_with<one_way_ne, explicit_operators>());
 } // namespace types_fit_for_purpose
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.common/common_with.compile.pass.cpp

 struct common_type<const volatile CommonWithIntButRefLong&, const volatile int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const volatile int&, const volatile CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 } // namespace std
 static_assert(CheckCommonWith<CommonWithIntButRefLong, int>());
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.commonref/common_reference.compile.pass.cpp

 
 template <template <class> class X, template <class> class Y>
 struct basic_common_reference<int, HasCommonReference, X, Y> {
   using type = int&;
 };
 } // namespace std
 static_assert(!std::common_reference_with<HasCommonReference, int>);
 static_assert(std::common_reference_with<HasCommonReference, int&>);
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp

void test() {
   test<std::unique_ptr<int>, std::unique_ptr<int> >();
   test<std::unique_ptr<int>, std::unique_ptr<int>&>();
   test<std::unique_ptr<int>, std::unique_ptr<int>&&>();
 
   test<std::array<int, 1> >();
   test<std::array<int, 1>, int>();
   test<std::array<int, 1>, int, int>();
 }
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.copyconstructible/copy_constructible.compile.pass.cpp

 static_assert(!std::copy_constructible<CopyOnly>);
 
 struct ExplicitlyCopyable {
   ExplicitlyCopyable(ExplicitlyCopyable&&) = default;
   explicit ExplicitlyCopyable(const ExplicitlyCopyable&);
 };
 static_assert(!std::copy_constructible<ExplicitlyCopyable>);
 } // namespace CopyConstructibleTests
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp

#endif
     test_true     <std::u32string_view>();
 
     // Smart pointers
     test_true     <std::unique_ptr<int>>();
     test_true     <std::shared_ptr<int>>();
     test_true     <std::weak_ptr<int>>();
 
 }
-
-// Required for MSVC internal test runner compatibility.
-int main(int, char**) {
-    return 0;
-}

libcxx/test/std/concepts/concepts.lang/concept.destructible/destructible.compile.pass.cpp

void test() {
   test<NoexceptDependant<int> >();
   test<NoexceptDependant<double> >();
 
   test<bool>();
   test<char>();
   test<int>();
   test<double>();
 }
-
-// Required for MSVC internal test runner compatibility.
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.moveconstructible/move_constructible.compile.pass.cpp

 static_assert(std::move_constructible<ImplicitlyDeletedMoveAssign&>);
 static_assert(std::move_constructible<ImplicitlyDeletedMoveAssign&&>);
 static_assert(std::move_constructible<const ImplicitlyDeletedMoveAssign&>);
 static_assert(std::move_constructible<const ImplicitlyDeletedMoveAssign&&>);
 
 static_assert(!std::move_constructible<NonMovable>);
 static_assert(!std::move_constructible<DerivedFromNonMovable>);
 static_assert(!std::move_constructible<HasANonMovable>);
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.object/copyable.compile.pass.cpp

 static_assert(!std::copyable<has_lvalue_reference_member>);
 static_assert(!std::copyable<has_rvalue_reference_member>);
 static_assert(!std::copyable<has_function_ref_member>);
 
 static_assert(
     !std::assignable_from<deleted_assignment_from_const_rvalue&,
                           deleted_assignment_from_const_rvalue const>);
 static_assert(!std::copyable<deleted_assignment_from_const_rvalue>);
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.object/movable.compile.pass.cpp

 static_assert(!std::movable<has_lvalue_reference_member>);
 static_assert(!std::movable<has_rvalue_reference_member>);
 static_assert(!std::movable<has_function_ref_member>);
 
 static_assert(std::movable<deleted_assignment_from_const_rvalue>);
 
 // `move_constructible and assignable_from<T&, T>` implies `swappable<T>`,
 // so there's nothing to test for the case of non-swappable.
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.object/regular.compile.pass.cpp

 // not equality_comparable
 static_assert(!std::regular<const_copy_assignment const>);
 static_assert(!std::regular<cv_copy_assignment const volatile>);
 
 struct is_equality_comparable {
   bool operator==(is_equality_comparable const&) const = default;
 };
 static_assert(std::regular<is_equality_comparable>);
-
-int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.object/semiregular.compile.pass.cpp

 
 static_assert(!std::semiregular<no_default_ctor>);
 static_assert(!std::semiregular<derived_from_non_default_initializable>);
 static_assert(!std::semiregular<has_non_default_initializable>);
 
 static_assert(!std::semiregular<deleted_default_ctor>);
 static_assert(!std::semiregular<derived_from_deleted_default_ctor>);
 static_assert(!std::semiregular<has_deleted_default_ctor>);
-
-int main(int, char**) { return 0; }

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp

 
 struct Works {
   unsigned char operator()();
 
   static constexpr unsigned char min() { return 0; }
   static constexpr unsigned char max() { return 1; }
 };
 static_assert(std::uniform_random_bit_generator<Works>);
-
-int main(int, char**) { return 0; }

libcxx/test/std/utilities/format/format.arguments/format.args/types.compile.pass.cpp

 #include "test_macros.h"
 
 static_assert(std::is_same_v<std::format_args,
                              std::basic_format_args<std::format_context>>);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert(std::is_same_v<std::wformat_args,
                              std::basic_format_args<std::wformat_context>>);
 #endif
-
-// Required for MSVC internal test runner compatibility.
-int main(int, char**) { return 0; }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/types.compile.pass.cpp

 }
 
 static_assert(std::is_same_v<std::format_parse_context,
                              std::basic_format_parse_context<char> >);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert(std::is_same_v<std::wformat_parse_context,
                              std::basic_format_parse_context<wchar_t> >);
 #endif
-
-// Required for MSVC internal test runner compatibility.
-int main(int, char**) { return 0; }

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_reference.compile.pass.cpp

static_assert(!has_type<std::common_reference_t<std::pair<const int&, volatile int&>,
                         std::pair<volatile int&, const int&>>>);
 
 static_assert(std::is_same_v<std::common_reference_t<std::pair<int, X2>, std::pair<int, Y2>>, std::pair<int, Z2>>);
 static_assert(std::is_same_v<std::common_reference_t<std::pair<int, X2>, std::pair<int, Y2>>, std::pair<int, Z2>>);
 static_assert(!has_type<std::common_reference<std::pair<int, const X2>, std::pair<float, const Z2>>>);
 static_assert(!has_type<std::common_reference<std::pair<int, X2>, std::pair<float, Z2>>>);
 static_assert(!has_type<std::common_reference<std::pair<int, X2>, int, X2>>);
 #endif
-
-int main(int, char**) { return 0; }