[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/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.verify.cpp

 {
     std::ptrdiff_t operator()(std::ptrdiff_t n)
     {
         return n-1;
     }
 };
 
 
-int main(int, char**)
-{
+void f() {
     int v[1] = {1};
     std::random_shuffle(&v[0], &v[1]); // expected-warning {{'random_shuffle<int *>' is deprecated}}
     gen r;
     std::random_shuffle(&v[0], &v[1], r); // expected-warning {{'random_shuffle<int *, gen &>' is deprecated}}
-
-  return 0;
 }

libcxx/test/libcxx/atomics/bit-int.verify.cpp

 // See https://reviews.llvm.org/D84049 for details.
 
 // UNSUPPORTED: apple-clang-14
 
 // UNSUPPORTED: c++03
 
 #include <atomic>
 
-int main(int, char**)
-{
+void f() {
   // expected-error@*:*1 {{_Atomic cannot be applied to integer type '_BitInt(32)'}}
   std::atomic<_BitInt(32)> x(42);
-
-  return 0;
 }

libcxx/test/libcxx/atomics/diagnose_invalid_memory_order.verify.cpp

 // REQUIRES: diagnose-if-support
 
 // <atomic>
 
 // Test that invalid memory order arguments are diagnosed where possible.
 
 #include <atomic>
 
-int main(int, char**) {
+void f() {
     std::atomic<int> x(42);
     volatile std::atomic<int>& vx = x;
     int val1 = 1; ((void)val1);
     int val2 = 2; ((void)val2);
     // load operations
     {
         x.load(std::memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}
         x.load(std::memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
// compare exchange strong
         std::atomic_compare_exchange_strong_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}
         std::atomic_compare_exchange_strong_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
         // valid memory orders
         std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_relaxed);
         std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_consume);
         std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acquire);
         std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst);
     }
-
-  return 0;
 }

libcxx/test/libcxx/containers/associative/non_const_comparator.incomplete.verify.cpp

 // too early for containers of incomplete types.
 //
 // See PR41360.
 
 #include <set>
 #include <map>
 #include <functional>
 
-#include "test_macros.h"
-
-
 template <template <typename ...> class Container>
 void test_set() {
   struct KeyBase { };
   struct KeyDerived;  // derives from KeyBase, but incomplete at this point
 
   // Name the type but don't instantiate it.
   using C = Container<KeyDerived*, std::less<KeyBase*>>;
 
void test_map() {
   struct KeyBase { };
   struct KeyDerived;
   using C = Container<KeyDerived*, Value, std::less<KeyBase*>>;
   typename C::value_type dummy; (void)dummy;
   struct KeyDerived : KeyBase { };
   C c;
 }
 
-int main(int, char**) {
+void f() {
   // expected-no-diagnostics
   test_set<std::set>();
   test_set<std::multiset>();
   test_map<std::map>();
   test_map<std::multimap>();
-
-  return 0;
 }

libcxx/test/libcxx/containers/associative/non_const_comparator.verify.cpp

 
 struct BadCompare {
   template <class T, class U>
   bool operator()(T const& t, U const& u) {
     return t < u;
   }
 };
 
-int main(int, char**) {
+void f() {
   static_assert(!std::__invokable<BadCompare const&, int const&, int const&>::value, "");
   static_assert(std::__invokable<BadCompare&, int const&, int const&>::value, "");
 
   // expected-warning@set:* 2 {{the specified comparator type does not provide a viable const call operator}}
   // expected-warning@map:* 2 {{the specified comparator type does not provide a viable const call operator}}
   {
     using C = std::set<int, BadCompare>;
     C s;
   }
   {
     using C = std::multiset<long, BadCompare>;
     C s;
   }
   {
     using C = std::map<int, int, BadCompare>;
     C s;
   }
   {
     using C = std::multimap<long, int, BadCompare>;
     C s;
   }
-
-  return 0;
 }

libcxx/test/libcxx/containers/unord/non_const_comparator.incomplete.verify.cpp

void test_map() {
   struct KeyBase { };
   struct KeyDerived;
   using C = Container<KeyDerived*, Value, std::hash<KeyBase*>, std::equal_to<KeyBase*>>;
   typename C::value_type dummy; (void)dummy;
   struct KeyDerived : KeyBase { };
   C c;
 }
 
-int main(int, char**) {
+void f() {
   // expected-no-diagnostics
   test_set<std::unordered_set>();
   test_set<std::unordered_multiset>();
   test_map<std::unordered_map>();
   test_map<std::unordered_multimap>();
-
-  return 0;
 }

libcxx/test/libcxx/containers/unord/non_const_comparator.verify.cpp

 
 struct BadEqual {
   template <class T, class U>
   bool operator()(T const& t, U const& u) {
     return t == u;
   }
 };
 
-int main(int, char**) {
+void f() {
   static_assert(!std::__invokable<BadEqual const&, int const&, int const&>::value, "");
   static_assert(std::__invokable<BadEqual&, int const&, int const&>::value, "");
 
   // expected-warning@unordered_set:* 2 {{the specified comparator type does not provide a viable const call operator}}
   // expected-warning@unordered_map:* 2 {{the specified comparator type does not provide a viable const call operator}}
   // expected-warning@unordered_set:* 2 {{the specified hash functor does not provide a viable const call operator}}
   // expected-warning@unordered_map:* 2 {{the specified hash functor does not provide a viable const call operator}}
 
   {
     using C = std::unordered_set<int, BadHash, BadEqual>;
     C s;
   }
   {
     using C = std::unordered_multiset<long, BadHash, BadEqual>;
     C s;
   }
   {
     using C = std::unordered_map<int, int, BadHash, BadEqual>;
     C s;
   }
   {
     using C = std::unordered_multimap<long, int, BadHash, BadEqual>;
     C s;
   }
-
-  return 0;
 }

libcxx/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.verify.cpp

 
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
 
 #include <memory>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    typedef std::auto_ptr<int> AP; // expected-warning {{'auto_ptr<int>' is deprecated}}
-    typedef std::auto_ptr<void> APV; // expected-warning {{'auto_ptr<void>' is deprecated}}
-    typedef std::auto_ptr_ref<int> APR; // expected-warning {{'auto_ptr_ref<int>' is deprecated}}
-
-  return 0;
-}

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.depr_in_cxx17.verify.cpp

 
 // Deprecated in C++17
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 
 #include <memory>
-#include "test_macros.h"
 
-int main(int, char**)
-{
+void f() {
   int x = 0;
   std::allocator<int> a;
 
-  int* p = a.address(x); // expected-warning {{'address' is deprecated}}
-  (void)p;
-
-  return 0;
+  (void)a.address(x); // expected-warning {{'address' is deprecated}}
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.cxx2a.verify.cpp

 //  In C++20, parts of std::allocator<T> have been removed.
 //  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 //  is defined before including <memory>, then removed members will be restored.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <memory>
-#include <cassert>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::allocator<int> a;
     a.allocate(3, nullptr); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.depr_in_cxx17.verify.cpp

 
 // Deprecated in C++17
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 
 #include <memory>
+
 #include "test_macros.h"
 
-int main(int, char**)
-{
+void f() {
     std::allocator<int> a;
     TEST_IGNORE_NODISCARD a.allocate(3, nullptr); // expected-warning {{'allocate' is deprecated}}
-
-    return 0;
 }

libcxx/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 #include <cassert>
-#include "test_macros.h"
 
 int identity(int v) { return v; }
 int sum(int a, int b) { return a + b; }
 
 struct Foo {
     int const_zero() const { return 0; }
     int const_identity(int v) const { return v; }
     int zero() { return 0; }
     int identity(int v) { return v; }
 };
 
-int main(int, char**)
-{
+void f() {
     typedef std::pointer_to_unary_function<int, int> PUF; // expected-warning {{'pointer_to_unary_function<int, int>' is deprecated}}
     typedef std::pointer_to_binary_function<int, int, int> PBF; // expected-warning {{'pointer_to_binary_function<int, int, int>' is deprecated}}
     std::ptr_fun<int, int>(identity); // expected-warning {{'ptr_fun<int, int>' is deprecated}}
     std::ptr_fun<int, int, int>(sum); // expected-warning {{'ptr_fun<int, int, int>' is deprecated}}
 
     typedef std::mem_fun_t<int, Foo> MFT0; // expected-warning {{'mem_fun_t<int, Foo>' is deprecated}}
     typedef std::mem_fun1_t<int, Foo, int> MFT1; // expected-warning {{'mem_fun1_t<int, Foo, int>' is deprecated}}
     typedef std::const_mem_fun_t<int, Foo> CMFT0; // expected-warning {{'const_mem_fun_t<int, Foo>' is deprecated}}
     typedef std::const_mem_fun1_t<int, Foo, int> CMFT1; // expected-warning {{'const_mem_fun1_t<int, Foo, int>' is deprecated}}
     std::mem_fun<int, Foo>(&Foo::zero); // expected-warning {{'mem_fun<int, Foo>' is deprecated}}
     std::mem_fun<int, Foo, int>(&Foo::identity); // expected-warning {{'mem_fun<int, Foo, int>' is deprecated}}
     std::mem_fun<int, Foo>(&Foo::const_zero); // expected-warning {{'mem_fun<int, Foo>' is deprecated}}
     std::mem_fun<int, Foo, int>(&Foo::const_identity); // expected-warning {{'mem_fun<int, Foo, int>' is deprecated}}
 
     typedef std::mem_fun_ref_t<int, Foo> MFR0; // expected-warning {{'mem_fun_ref_t<int, Foo>' is deprecated}}
     typedef std::mem_fun1_ref_t<int, Foo, int> MFR1; // expected-warning {{'mem_fun1_ref_t<int, Foo, int>' is deprecated}}
     typedef std::const_mem_fun_ref_t<int, Foo> CMFR0; // expected-warning {{'const_mem_fun_ref_t<int, Foo>' is deprecated}}
     typedef std::const_mem_fun1_ref_t<int, Foo, int> CMFR1; // expected-warning {{'const_mem_fun1_ref_t<int, Foo, int>' is deprecated}}
     std::mem_fun_ref<int, Foo>(&Foo::zero); // expected-warning {{'mem_fun_ref<int, Foo>' is deprecated}}
     std::mem_fun_ref<int, Foo, int>(&Foo::identity); // expected-warning {{'mem_fun_ref<int, Foo, int>' is deprecated}}
     std::mem_fun_ref<int, Foo>(&Foo::const_zero); // expected-warning {{'mem_fun_ref<int, Foo>' is deprecated}}
     std::mem_fun_ref<int, Foo, int>(&Foo::const_identity); // expected-warning {{'mem_fun_ref<int, Foo, int>' is deprecated}}
-
-  return 0;
 }

libcxx/test/libcxx/diagnostics/nodiscard_aftercxx17.verify.cpp

 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: (c++11 || c++14 || c++17) && !stdlib=libc++
 
 #include <__config>
 
 _LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
 
-int main(int, char**)
-{
+void f() {
     foo(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

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/diagnostics/nodiscard_extensions.verify.cpp

 
 #if TEST_STD_VER > 20
   enum E { Apple, Orange } e = Apple;
   // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
   std::to_underlying(e);
 #endif
 }
 
-int main(int, char**) {
+void f() {
   test_algorithms();
 
   int i = 42;
   test_template_cast_wrappers(i, std::move(i));
   test_nontemplate_cast_wrappers();
-
-  return 0;
 }

libcxx/test/libcxx/iterators/predef.iterators/__unconstrained_reverse_iterator/reverse.iter.cons/ctor.iter.explicit.verify.cpp

 // __unconstrained_reverse_iterator
 
 // explicit __unconstrained_reverse_iterator(Iter x);
 
 // test explicitness
 
 #include <iterator>
 
-int main(int, char**) {
+void f() {
     char const* it = "";
     std::__unconstrained_reverse_iterator<char const*> r = it; // expected-error{{no viable conversion from 'const char *' to 'std::__unconstrained_reverse_iterator<const char *>'}}
-    return 0;
 }

libcxx/test/libcxx/iterators/predef.iterators/reverse.iterators/bad_template_argument.verify.cpp

 // <iterator>
 
 // reverse_iterator
 
 #include <iterator>
 
 #include "test_iterators.h"
 
-int main(int, char**) {
+void f() {
   using BadIter = std::reverse_iterator<forward_iterator<int*>>;
   BadIter i; //expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}reverse_iterator<It> requires It to be a bidirectional iterator.}}
-
-  return 0;
 }

libcxx/test/libcxx/language.support/support.dynamic/aligned_alloc_availability.verify.cpp

 #include <cstddef>
 
 #include "test_macros.h"
 
 constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 struct alignas(OverAligned) A { };
 
-int main(int, char**)
-{
+void f() {
     // Normal versions
     {
         A *a1 = new A; // expected-error-re {{aligned allocation function of type {{.+}} is only available on}}
         // `delete` is also required by the line above if construction fails
         // expected-error-re@-2 {{aligned deallocation function of type {{.+}} is only available on}}
 
         delete a1; // expected-error-re {{aligned deallocation function of type {{.+}} is only available on}}
 

libcxx/test/libcxx/numerics/rand/rand.device/has-no-random-device.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure that std::random_device is not available in namespace std:: when
 // libc++ is built without support for random device.
 
 // REQUIRES: no-random-device
 
 #include <random>
 
-int main(int, char**) {
+void f() {
   std::random_device d; // expected-error {{no type named 'random_device' in namespace 'std'}}
-  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/selftest/verify.cpp/no-werror.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure clang-verify tests distinguish warnings from errors.
 
 // ADDITIONAL_COMPILE_FLAGS: -Wunused-variable
 
-int main(int, char**) {
+void f() {
     int foo; // expected-warning {{unused variable}}
-    return 0;
 }

libcxx/test/libcxx/thread/atomic.availability.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // REQUIRES: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
-
 // Test the availability markup on the C++20 Synchronization Library
 // additions to <atomic>.
 
 #include <atomic>
 
-
-int main(int, char**)
-{
+void f() {
     {
         std::atomic<int> i(3);
         std::memory_order m = std::memory_order_relaxed;
 
         i.wait(4); // expected-error {{is unavailable}}
         i.wait(4, m); // expected-error {{is unavailable}}
         i.notify_one(); // expected-error {{is unavailable}}
         i.notify_all(); // expected-error {{is unavailable}}

libcxx/test/libcxx/thread/barrier.availability.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // REQUIRES: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
-
 // Test the availability markup on std::barrier.
 
 #include <barrier>
 #include <utility>
 
 struct CompletionF {
     void operator()() { }
 };
 
-int main(int, char**)
-{
+void f() {
     // Availability markup on std::barrier<>
     {
         std::barrier<> b(10); // expected-error {{is unavailable}}
         auto token = b.arrive(); // expected-error {{is unavailable}}
         (void)b.arrive(10); // expected-error {{is unavailable}}
         b.wait(std::move(token)); // expected-error {{is unavailable}}
         b.arrive_and_wait(); // expected-error {{is unavailable}}
         b.arrive_and_drop(); // expected-error {{is unavailable}}

libcxx/test/libcxx/thread/latch.availability.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // REQUIRES: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
-
 // Test the availability markup on std::latch.
 
 #include <latch>
 
-
-int main(int, char**)
-{
+void f() {
     std::latch latch(10);
     latch.count_down(); // expected-error {{is unavailable}}
     latch.count_down(3); // expected-error {{is unavailable}}
     latch.wait(); // expected-error {{is unavailable}}
     latch.arrive_and_wait(); // expected-error {{is unavailable}}
     latch.arrive_and_wait(3); // expected-error {{is unavailable}}
 }

libcxx/test/libcxx/thread/semaphore.availability.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // REQUIRES: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
-
 // Test the availability markup on std::counting_semaphore and std::binary_semaphore.
 
 #include <chrono>
 #include <semaphore>
 
-
-int main(int, char**)
-{
+void f() {
     {
         // Tests for std::counting_semaphore with non-default template argument
         std::counting_semaphore<20> sem(10);
         sem.release(); // expected-error {{is unavailable}}
         sem.release(5); // expected-error {{is unavailable}}
         sem.acquire(); // expected-error {{is unavailable}}
         sem.try_acquire_for(std::chrono::milliseconds{3}); // expected-error 1-2 {{is unavailable}}
         sem.try_acquire(); // expected-error {{is unavailable}}

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.lock/thread.lock.guard/nodiscard.verify.cpp

 // [[nodiscard]] explicit lock_guard(mutex_type& m);
 // [[nodiscard]] lock_guard(mutex_type& m, adopt_lock_t);
 
 // Test that we properly apply [[nodiscard]] to lock_guard's constructors,
 // which is a libc++ extension.
 
 #include <mutex>
 
-int main(int, char**) {
+void f() {
     std::mutex m;
     std::lock_guard<std::mutex>{m}; // expected-warning {{ignoring temporary created by a constructor declared with 'nodiscard' attribute}}
     std::lock_guard<std::mutex>{m, std::adopt_lock}; // expected-warning {{ignoring temporary created by a constructor declared with 'nodiscard' attribute}}
-    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/atomics/atomics.types.operations/atomics.types.operations.req/copy.assign.ptr.volatile.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <atomic>
 
 // std::atomic
 
 // atomic& operator=( const atomic& ) volatile = delete;
 
 #include <atomic>
 
-int main(int, char**)
-{
+void f() {
     volatile std::atomic<int*> obj1;
     std::atomic<int*> obj2;
     obj1 = obj2; // expected-error {{overload resolution selected deleted operator '='}}
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/copy.assign.volatile.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <atomic>
 
 // std::atomic
 
 // atomic& operator=( const atomic& ) volatile = delete;
 
 #include <atomic>
 
-int main(int, char**)
-{
+void f() {
   volatile std::atomic<int> obj1;
   std::atomic<int> obj2;
   obj1 = obj2; // expected-error {{overload resolution selected deleted operator '='}}
 }

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.default.init/default_initializable.verify.cpp

void test() {
     // Zero-length array extension
     const int x4[]; // expected-error {{definition of variable with array type needs an explicit size or an initializer}}
     const int y4[]{};
     static_assert(!std::constructible_from<const int[]>);
     static_assert(brace_initializable<const int[]>);
     LIBCPP_STATIC_ASSERT(!std::__default_initializable<const int[]>);
     static_assert(!std::default_initializable<const int[]>);
 }
-
-int main(int, char**) {
-    test();
-
-    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/containers/associative/map/map.access/empty.verify.cpp

 // class map
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <map>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::map<int, int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/associative/multimap/empty.verify.cpp

 // class multimap
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <map>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::multimap<int, int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/associative/multiset/empty.verify.cpp

 // class multiset
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <set>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::multiset<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/associative/set/empty.verify.cpp

 // class set
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <set>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::set<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.verify.cpp

 // class priority_queue
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <queue>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::priority_queue<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/container.adaptors/queue/queue.defn/empty.verify.cpp

 // class queue
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <queue>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::queue<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/container.adaptors/stack/stack.defn/empty.verify.cpp

 // class stack
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <stack>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::stack<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/sequences/array/empty.verify.cpp

 // class array
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <array>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
-
+void f() {
     std::array<int, 1> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::array<int, 0> c0;
     c0.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.capacity/empty.verify.cpp

 // class deque
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <deque>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::deque<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/empty.verify.cpp

 // class forward_list
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <forward_list>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::forward_list<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/sequences/list/list.capacity/empty.verify.cpp

 // class list
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <list>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::list<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/empty.verify.cpp

 // class vector
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <vector>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::vector<bool> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/empty.verify.cpp

 // class vector
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <vector>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::vector<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.cons/copy.move_only.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure that a std::vector containing move-only types can't be copied.
 
 // UNSUPPORTED: c++03 && !stdlib=libc++
 
 #include <vector>
 
 #include "MoveOnly.h"
 
-int main(int, char**)
-{
+void f() {
     std::vector<MoveOnly> v;
     std::vector<MoveOnly> copy = v; // expected-error-re@* {{{{(no matching function for call to 'construct_at')|(call to implicitly-deleted copy constructor of 'MoveOnly')|(call to deleted constructor of 'MoveOnly')}}}}
-    return 0;
 }

libcxx/test/std/containers/unord/unord.map/empty.verify.cpp

 // class unordered_map
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <unordered_map>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::unordered_map<int, int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/empty.verify.cpp

 // class unordered_multimap
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <unordered_map>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::unordered_multimap<int, int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/empty.verify.cpp

 // class unordered_multiset
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <unordered_set>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::unordered_multiset<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/unord/unord.set/empty.verify.cpp

 // class unordered_set
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <unordered_set>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::unordered_set<int> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/containers/views/views.span/span.cons/iterator_len.verify.cpp

 #include <span>
 #include <cstddef>
 
 template <class T, size_t extent>
 std::span<T, extent> createImplicitSpan(T* ptr, size_t len) {
   return {ptr, len}; // expected-error {{chosen constructor is explicit in copy-initialization}}
 }
 
-int main(int, char**) {
+void f() {
   // explicit constructor necessary
   int arr[] = {1, 2, 3};
   createImplicitSpan<int, 1>(arr, 3);
 
   std::span<int> sp = {0, 0}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
   std::span<int, 2> sp2 = {0, 0}; // expected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
   std::span<const int> csp = {0, 0}; // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
   std::span<const int, 2> csp2 = {0, 0}; // expected-error {{no matching constructor for initialization of 'std::span<const int, 2>'}}
-
-  return 0;
 }

libcxx/test/std/containers/views/views.span/span.cons/iterator_sentinel.verify.cpp

 // constexpr explicit(Extent != dynamic_extent) span(It first, End last);
 // Requires: [first, last) shall be a valid range.
 //   If Extent is not equal to dynamic_extent, then last - first shall be equal to Extent.
 //
 
 #include <span>
 #include <iterator>
 
-
 template<class T, size_t Extent>
 std::span<T, Extent> createImplicitSpan(T* first, T* last) {
     return {first, last}; // expected-error {{chosen constructor is explicit in copy-initialization}}
 }
 
-int main(int, char**) {
+void f() {
   // explicit constructor necessary
   int arr[] = {1, 2, 3};
   createImplicitSpan<int, 1>(std::begin(arr), std::end(arr));
-
-  return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.verify.cpp

 // bind1st
 
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
-#include "test_macros.h"
 
-int main(int, char**)
-{
+void f() {
     std::bind1st(test_func(1), 5); // expected-warning {{'bind1st<test_func, int>' is deprecated}}
-
-    return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.verify.cpp

 // bind2nd
 
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
-#include "test_macros.h"
 
-int main(int, char**)
-{
+void f() {
     std::bind2nd(test_func(1), 5); // expected-warning {{'bind2nd<test_func, int>' is deprecated}}
-
-    return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.verify.cpp

 // binder1st
 
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
-#include "test_macros.h"
 
-int main(int, char**)
-{
-    typedef std::binder1st<test_func> B1ST; // expected-warning {{'binder1st<test_func>' is deprecated}}
-
-    return 0;
-}

libcxx/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.verify.cpp

 // binder2nd
 
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
-#include "test_macros.h"
 
-int main(int, char**)
-{
-    typedef std::binder2nd<test_func> B2ND; // expected-warning {{'binder2nd<test_func>' is deprecated}}
-
-    return 0;
-}

libcxx/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.verify.cpp

 // class path
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include "filesystem_include.h"
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     fs::path c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/input.output/iostream.format/quoted.manip/quoted_char.verify.cpp

 // quoted
 
 // UNSUPPORTED: c++03, c++11
 // XFAIL: no-wide-characters
 
 #include <iomanip>
 #include <sstream>
 #include <string>
-#include <cassert>
-
-#include "test_macros.h"
 
 //  Test that mismatches between strings and wide streams are diagnosed
 
 void round_trip ( const char *p ) {
     std::wstringstream ss;
     ss << std::quoted(p); // expected-error {{invalid operands to binary expression}}
     std::string s;
     ss >> std::quoted(s); // expected-error {{invalid operands to binary expression}}
 }
 
-int main(int, char**) {
+void f() {
     round_trip("Hi Mom");
 }

libcxx/test/std/input.output/iostream.format/quoted.manip/quoted_traits.verify.cpp

 
 // quoted
 
 // UNSUPPORTED: c++03, c++11
 
 #include <iomanip>
 #include <sstream>
 #include <string>
-#include <cassert>
-
-#include "test_macros.h"
 
 //  Test that mismatches in the traits between the quoted object and the dest string are diagnosed.
 
 template <class charT>
 struct test_traits {
     typedef charT char_type;
 };
 
 void round_trip ( const char *p ) {
     std::stringstream ss;
     ss << std::quoted(p);
     std::basic_string<char, test_traits<char>> s;
     ss >> std::quoted(s); // expected-error {{invalid operands to binary expression}}
 }
 
-int main(int, char**) {
+void f() {
     round_trip("Hi Mom");
 }

libcxx/test/std/iterators/iterator.container/empty.array.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // <iterator>
 // template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-#include <vector>
 #include <iterator>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     int c[5];
     std::empty(c); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/iterators/iterator.container/empty.container.verify.cpp

 // <iterator>
 // template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <vector>
 #include <iterator>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::vector<int> c;
     std::empty(c); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/iterators/iterator.container/empty.initializer_list.verify.cpp

 // <iterator>
 // template <class E> constexpr bool empty(initializer_list<E> il) noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <initializer_list>
 #include <iterator>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::initializer_list<int> c = { 4 };
     std::empty(c); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.nodiscard.verify.cpp

struct WithADL {
   WithADL() = default;
   constexpr decltype(auto) operator*() const noexcept;
   constexpr WithADL& operator++() noexcept;
   constexpr void operator++(int) noexcept;
   constexpr bool operator==(WithADL const&) const noexcept;
   friend constexpr auto iter_move(WithADL&) { return 0; }
 };
 
-int main(int, char**) {
+void f() {
   int* noADL = nullptr;
   std::ranges::iter_move(noADL); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
   WithADL adl;
   std::ranges::iter_move(adl); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-  return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/ctor.iter.explicit.verify.cpp

 // move_iterator
 
 // explicit move_iterator(Iter );
 
 // test explicitness
 
 #include <iterator>
 
-int main(int, char**) {
+void f() {
     char const* it = "";
     std::move_iterator<char const*> r = it; // expected-error{{no viable conversion from 'const char *' to 'std::move_iterator<const char *>'}}
-    return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/deprecated.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // move_iterator
 
 #include <iterator>
 
-int main(int, char**) {
-  (void)std::move_iterator<int*>().operator->();
-  // expected-warning@-1{{'operator->' is deprecated}}
-
-  return 0;
+void f() {
+  (void)std::move_iterator<int*>().operator->(); // expected-warning {{'operator->' is deprecated}}
 }

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.cons/ctor.iter.explicit.verify.cpp

 // reverse_iterator
 
 // explicit reverse_iterator(Iter x);
 
 // test explicitness
 
 #include <iterator>
 
-int main(int, char**) {
+void f() {
     char const* it = "";
     std::reverse_iterator<char const*> r = it; // expected-error{{no viable conversion from 'const char *' to 'std::reverse_iterator<const char *>'}}
-    return 0;
 }

libcxx/test/std/language.support/cmp/cmp.categories.pre/zero_type.verify.cpp

void test_category(T v) {
   TEST_PASS(v, !=);
   TEST_PASS(v, <);
   TEST_PASS(v, >);
   TEST_PASS(v, <=);
   TEST_PASS(v, >=);
   TEST_PASS(v, <=>);
 }
 
-int main(int, char**) {
+void f() {
   test_category(std::strong_ordering::equivalent);
   test_category(std::weak_ordering::equivalent);
   test_category(std::partial_ordering::equivalent);
-  return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.verify.cpp

 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
-int main(int, char**) {
+void f() {
     ::operator new[](4);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.verify.cpp

 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
-int main(int, char**) {
+void f() {
     ::operator new[](4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.verify.cpp

 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
-int main(int, char**) {
+void f() {
     ::operator new[](4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.verify.cpp

 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
-int main(int, char**) {
+void f() {
     ::operator new[](4, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <new>
 
 // void* operator new[](std::size_t, void *);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <new>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     char buffer[100];
     ::operator new[](4, buffer); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <new>
 
 // void* operator new(std::size_t, void *);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <new>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     char buffer[100];
     ::operator new(4, buffer); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <new>
 
 // void* operator new(std::size_t);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <new>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     ::operator new(4); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.verify.cpp

 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
-int main(int, char**) {
+void f() {
     ::operator new(4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.verify.cpp

 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
-int main(int, char**) {
+void f() {
     ::operator new(4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <new>
 
 // void* operator new(std::size_t, std::nothrow_t &);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <new>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     ::operator new(4, std::nothrow); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <new>
 
 // template <class T> constexpr T* launder(T* p) noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORETD: c++17 && !stdlib=libc++
+// UNSUPPORTED: c++17 && !stdlib=libc++
 
 #include <new>
-#include <cassert>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     int *p = nullptr;
     std::launder(p); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/codecvt_byname_char16_t_char.depr_in_cxx20.verify.cpp

 // codecvt_byname<char16_t, char, mbstate_t>
 //  deprecated in C++20
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <locale>
 
 #include "../with_public_dtor.hpp"
-#include "test_macros.h"
 
-int main(int, char **)
-{
+void f() {
     // Don't test for the exact type since the underlying type of
     // std::mbstate_t depends on implementation details.
     with_public_dtor<std::codecvt_byname<char16_t, char, std::mbstate_t>> cvt("", 0); // expected-warning-re {{'codecvt_byname<char16_t, char, {{.*}}>' is deprecated}}
     (void)cvt;
-
-    return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/codecvt_byname_char32_t_char.depr_in_cxx20.verify.cpp

 // codecvt_byname<char32_t, char, mbstate_t>
 //  deprecated in C++20
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <locale>
 
 #include "../with_public_dtor.hpp"
-#include "test_macros.h"
 
-int main(int, char **)
-{
+void f() {
     // Don't test for the exact type since the underlying type of
     // std::mbstate_t depends on implementation details.
     with_public_dtor<std::codecvt_byname<char32_t, char, std::mbstate_t>> cvt("", 0); // expected-warning-re {{'codecvt_byname<char32_t, char, {{.*}}>' is deprecated}}
     (void)cvt;
-
-    return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_char16_t_char.depr_in_cxx20.verify.cpp

 // codecvt<char16_t, char, mbstate_t>
 //  deprecated in C++20
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <locale>
 
 #include "../with_public_dtor.hpp"
-#include "test_macros.h"
 
-int main(int, char **)
-{
+void f() {
     // Don't test for the exact type since the underlying type of
     // std::mbstate_t depends on implementation details.
     with_public_dtor<std::codecvt<char16_t, char, std::mbstate_t>> cvt("", 0); // expected-warning-re {{'codecvt<char16_t, char, {{.*}}>' is deprecated}}
     (void)cvt;
-
-    return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_char32_t_char.depr_in_cxx20.verify.cpp

 // codecvt<char32_t, char, mbstate_t>
 //  deprecated in C++20
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <locale>
 
 #include "../with_public_dtor.hpp"
-#include "test_macros.h"
 
-int main(int, char **)
-{
+void f() {
     // Don't test for the exact type since the underlying type of
     // std::mbstate_t depends on implementation details.
     with_public_dtor<std::codecvt<char32_t, char, std::mbstate_t>> cvt("", 0); // expected-warning-re {{'codecvt<char32_t, char, {{.*}}>' is deprecated}}
     (void)cvt;
-
-    return 0;
 }

libcxx/test/std/numerics/numbers/illformed.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <numbers>
 
 // Initializing the primary template is ill-formed.
-int log2e{std::numbers::log2e_v<
-    int>}; // expected-error-re@numbers:* {{{{(static_assert|static assertion)}} failed{{.*}}A program that instantiates a primary template of a mathematical constant variable template is ill-formed.}}
+int log2e{std::numbers::log2e_v<int>}; // expected-error-re@numbers:* {{{{(static_assert|static assertion)}} failed{{.*}}A program that instantiates a primary template of a mathematical constant variable template is ill-formed.}}
 int log10e{std::numbers::log10e_v<int>};
 int pi{std::numbers::pi_v<int>};
 int inv_pi{std::numbers::inv_pi_v<int>};
 int inv_sqrtpi{std::numbers::inv_sqrtpi_v<int>};
 int ln2{std::numbers::ln2_v<int>};
 int ln10{std::numbers::ln10_v<int>};
 int sqrt2{std::numbers::sqrt2_v<int>};
 int sqrt3{std::numbers::sqrt3_v<int>};
 int inv_sqrt3{std::numbers::inv_sqrt3_v<int>};
 int egamma{std::numbers::egamma_v<int>};
 int phi{std::numbers::phi_v<int>};
-
-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/re/re.results/re.results.size/empty.verify.cpp

 
 // class match_results<BidirectionalIterator, Allocator>
 // bool empty() const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <regex>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::match_results<const char*> c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/empty.verify.cpp

 // class deque
 
 // bool empty() const noexcept; // constexpr since C++20
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <string>
 
-#include "test_macros.h"
-
-TEST_CONSTEXPR_CXX20 bool test() {
+void f() {
   std::string c;
   c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-  return true;
-}
-
-int main(int, char**)
-{
-  test();
-#if TEST_STD_VER > 17
-  static_assert(test());
-#endif
-
-  return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/reserve.deprecated_in_cxx20.verify.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>
 
 // void reserve(); // Deprecated in C++20
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <string>
 
-int main(int, char**)
-{
+void f() {
     std::string s;
     s.reserve(); // expected-warning {{'reserve' is deprecated}}
-    return 0;
 }

libcxx/test/std/strings/string.view/string.view.capacity/empty.verify.cpp

 // class string_view
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <string_view>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::string_view c;
     c.empty();  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/thread/futures/futures.async/async.verify.cpp

 //     async(F&& f, Args&&... args);
 
 // template <class F, class... Args>
 //     future<typename result_of<F(Args...)>::type>
 //     async(launch policy, F&& f, Args&&... args);
 
 
 #include <future>
-#include <atomic>
-#include <memory>
-#include <cassert>
-
-#include "test_macros.h"
 
 int foo (int x) { return x; }
 
-int main(int, char**)
-{
+void f() {
     std::async(                    foo, 3); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::async(std::launch::async, foo, 3); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/thread/futures/futures.promise/copy_assign.verify.cpp

 // <future>
 
 // class promise<R>
 
 // promise& operator=(const promise& rhs) = delete;
 
 #include <future>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     {
         std::promise<int> p0, p;
         p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
     {
         std::promise<int&> p0, p;
         p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
     {
         std::promise<void> p0, p;
         p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
-
-    return 0;
 }

libcxx/test/std/thread/futures/futures.promise/copy_ctor.verify.cpp

 // <future>
 
 // class promise<R>
 
 // promise(const promise&) = delete;
 
 #include <future>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     {
         std::promise<int> p0;
         std::promise<int> p(p0); // expected-error {{call to deleted constructor of 'std::promise<int>'}}
     }
     {
         std::promise<int &> p0;
         std::promise<int &> p(p0); // expected-error {{call to deleted constructor of 'std::promise<int &>'}}
     }
     {
         std::promise<void> p0;
         std::promise<void> p(p0); // expected-error {{call to deleted constructor of 'std::promise<void>'}}
     }
-
-    return 0;
 }

libcxx/test/std/thread/futures/futures.unique_future/copy_assign.verify.cpp

 // <future>
 
 // class future<R>
 
 // future& operator=(const future&) = delete;
 
 #include <future>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     {
         std::future<int> f0, f;
         f = f0; // expected-error {{overload resolution selected deleted operator '='}}
     }
     {
         std::future<int &> f0, f;
         f = f0; // expected-error {{overload resolution selected deleted operator '='}}
     }
     {
         std::future<void> f0, f;
         f = f0; // expected-error {{overload resolution selected deleted operator '='}}
     }
-
-    return 0;
 }

libcxx/test/std/thread/futures/futures.unique_future/copy_ctor.verify.cpp

 // <future>
 
 // class future<R>
 
 // future(const future&) = delete;
 
 #include <future>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     {
         std::future<int> f0;
         std::future<int> f = f0; // expected-error {{call to deleted constructor of 'std::future<int>'}}
     }
     {
         std::future<int &> f0;
         std::future<int &> f = f0; // expected-error {{call to deleted constructor of 'std::future<int &>'}}
     }
     {
         std::future<void> f0;
         std::future<void> f = f0; // expected-error {{call to deleted constructor of 'std::future<void>'}}
     }
-
-    return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.verify.cpp

 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
 //   class scoped_allocator_adaptor
 
 // pointer allocate(size_type n);
 
 #include <scoped_allocator>
-#include <cassert>
 
 #include "allocators.h"
 
-int main(int, char**)
-{
+void f() {
     std::scoped_allocator_adaptor<A1<int>> a;
     a.allocate(10);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.verify.cpp

 // <memory>
 
 // template <class OuterAlloc, class... InnerAllocs>
 //   class scoped_allocator_adaptor
 
 // pointer allocate(size_type n, const_void_pointer hint);
 
 #include <scoped_allocator>
-#include <cassert>
 
 #include "allocators.h"
 
-int main(int, char**)
-{
+void f() {
     std::scoped_allocator_adaptor<A1<int>> a;
     a.allocate(10, (const void*)0); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp

 // clang-verify to make the test more robust to changes in Clang.
 // ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error
 
 #include <any>
 
 struct TestType {};
 struct TestType2 {};
 
-int main(int, char**)
-{
+void f() {
     std::any a;
 
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType &>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType &&>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType2 &>(static_cast<std::any const&&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<TestType2 &&>(static_cast<std::any const&&>(a)); // expected-note {{requested here}}
-
-  return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp

 // constraints are not respected, however Clang will sometimes emit
 // additional errors while trying to instantiate the rest of any_cast
 // following the static_assert. We ignore unexpected errors in
 // clang-verify to make the test more robust to changes in Clang.
 // ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error
 
 #include <any>
 
-struct no_copy
-{
+struct no_copy {
     no_copy() {}
     no_copy(no_copy &&) {}
     no_copy(no_copy const &) = delete;
 };
 
 struct no_move {
     no_move() {}
     no_move(no_move&&) = delete;
     no_move(no_move const&) {}
 };
 
-int main(int, char**) {
+void f() {
     std::any a;
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an lvalue reference or a CopyConstructible type}}
     std::any_cast<no_copy>(static_cast<std::any&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be a const lvalue reference or a CopyConstructible type}}
     std::any_cast<no_copy>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
     std::any_cast<no_copy>(static_cast<std::any &&>(a)); // OK
 
     // expected-error-re@any:* {{{{(static_assert|static assertion)}} failed{{.*}}ValueType is required to be an rvalue reference or a CopyConstructible type}}
     std::any_cast<no_move>(static_cast<std::any &&>(a));
-
-  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/check_arg_id.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // constexpr void check_arg_id(size_t id);
 
 #include <format>
 
-#include "test_macros.h"
-
 constexpr bool test() {
   // [format.parse.ctx]/11
   // Remarks: Call expressions where id >= num_args_ are not
   // core constant expressions ([expr.const]).
   std::format_parse_context context("", 0);
   context.check_arg_id(1);
 
   return true;
 }
 
-int main(int, char**) {
+void f() {
   // expected-error-re@+1 {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
   static_assert(test());
-
-  return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // constexpr size_t next_arg_id()
 
 #include <format>
 
-#include "test_macros.h"
-
 constexpr bool test() {
   // [format.parse.ctx]/8
   // Let cur-arg-id be the value of next_arg_id_ prior to this call. Call
   // expressions where cur-arg-id >= num_args_ is true are not core constant
   // expressions (7.7 [expr.const]).
   std::format_parse_context context("", 0);
   context.next_arg_id();
 
   return true;
 }
 
-int main(int, char**) {
+void f() {
   // expected-error-re@+1 {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
   static_assert(test());
-
-  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/function.objects/func.bind_front/bind_front.verify.cpp

 
 // functional
 
 // template <class F, class... Args>
 // constexpr unspecified bind_front(F&&, Args&&...);
 
 #include <functional>
 
-#include "test_macros.h"
-
 constexpr int pass(const int n) { return n; }
 
 int simple(int n) { return n; }
 
 template<class T>
 T do_nothing(T t) { return t; }
 
 struct NotMoveConst
 {
     NotMoveConst(NotMoveConst &&) = delete;
     NotMoveConst(NotMoveConst const&) = delete;
 
     NotMoveConst(int) { }
 };
 
 void testNotMoveConst(NotMoveConst) { }
 
-int main(int, char**)
-{
+void f() {
     int n = 1;
     const int c = 1;
 
     auto p = std::bind_front(pass, c);
     static_assert(p() == 1); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
 
     auto d = std::bind_front(do_nothing, n); // expected-error {{no matching function for call to 'bind_front'}}
 
     auto t = std::bind_front(testNotMoveConst, NotMoveConst(0)); // expected-error {{no matching function for call to 'bind_front'}}
-
-    return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.verify.cpp

 
 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&);
 //
 // This signature was removed in C++17
 
 #include <functional>
-#include <cassert>
+#include <memory>
 
-#include "min_allocator.h"
-
-int main(int, char**)
-{
+void f() {
     std::function<int(int)> f(std::allocator_arg, std::allocator<int>()); // expected-error {{no matching constructor for initialization of}}
-    return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.verify.cpp

 
 // class function<R(ArgTypes...)>
 
 // template<class F, class A> function(allocator_arg_t, const A&, F);
 //
 // This signature was removed in C++17
 
 #include <functional>
-#include <cassert>
 #include <memory>
 
-#include "test_macros.h"
-
 void foo(int) {}
 
-int main(int, char**)
-{
+void f() {
     std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo); // expected-error {{no matching constructor for initialization of}}
-    return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.verify.cpp

 
 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&, const function&);
 //
 // This signature was removed in C++17
 
 #include <functional>
-#include <cassert>
 #include <memory>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     typedef std::function<void(int)> F;
     F f1;
     F f2(std::allocator_arg, std::allocator<int>(), f1); // expected-error {{no matching constructor for initialization of}}
-    return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.verify.cpp

 
 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&, nullptr_t);
 //
 // This signature was removed in C++17
 
 #include <functional>
-#include <cassert>
+#include <memory>
 
-#include "min_allocator.h"
-
-int main(int, char**)
-{
+void f() {
     std::function<int(int)> f(std::allocator_arg, std::allocator<int>(), nullptr); // expected-error {{no matching constructor for initialization of}}
-    return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.verify.cpp

 // UNSUPPORTED: c++03, c++11, c++14
 
 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&, function&&);
 //
 // This signature was removed in C++17
 
-#include <cassert>
 #include <functional>
 #include <memory>
 #include <utility>
 
-#include "test_macros.h"
-
 class A
 {
     int data_[10];
 public:
     static int count;
 
     A()
     {
int operator()(int i) const
         return i;
     }
 };
 
 int A::count = 0;
 
 int g(int) { return 0; }
 
-int main(int, char**)
-{
+void f() {
     std::function<int(int)> f = A();
     std::function<int(int)> f2(std::allocator_arg, std::allocator<A>(), std::move(f)); // expected-error {{no matching constructor for initialization of}}
-    return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_F.verify.cpp

 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // The deduction guides for std::function do not handle rvalue-ref qualified
 // call operators and C-style variadics. It also doesn't deduce from nullptr_t.
 // Make sure we stick to the specification.
 
 #include <functional>
-#include <type_traits>
 
 struct R { };
 struct f0 { R operator()() && { return {}; } };
 struct f1 { R operator()(int, ...) { return {}; } };
 
-int main(int, char**) {
+void f() {
     std::function f = f0{}; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'function'}}
     std::function g = f1{}; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'function'}}
     std::function h = nullptr; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'function'}}
-    return 0;
 }

libcxx/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.verify.cpp

 // binary_negate
 //  deprecated in C++17
 
 // UNSUPPORTED: c++03, c++11, c++14
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 
 #include <functional>
 
-#include "test_macros.h"
-
 struct Predicate {
     typedef int first_argument_type;
     typedef int second_argument_type;
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
-int main(int, char**) {
+void test() {
     std::binary_negate<Predicate> f((Predicate())); // expected-warning {{'binary_negate<Predicate>' is deprecated}}
     (void)f;
-
-    return 0;
 }

libcxx/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.verify.cpp

 // not1
 //  deprecated in C++17
 
 // UNSUPPORTED: c++03, c++11, c++14
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 
 #include <functional>
 
-#include "test_macros.h"
-
 struct Predicate {
     typedef int argument_type;
     bool operator()(argument_type) const { return true; }
 };
 
-int main(int, char**) {
+void f() {
     std::not1(Predicate()); // expected-warning {{'not1<Predicate>' is deprecated}}
-
-    return 0;
 }

libcxx/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.verify.cpp

 // not2
 //  deprecated in C++17
 
 // UNSUPPORTED: c++03, c++11, c++14
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 
 #include <functional>
 
-#include "test_macros.h"
-
 struct Predicate {
     typedef int first_argument_type;
     typedef int second_argument_type;
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
-int main(int, char**) {
+void f() {
     std::not2(Predicate()); // expected-warning {{'not2<Predicate>' is deprecated}}
-
-    return 0;
 }

libcxx/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.verify.cpp

 // unary_negate
 //  deprecated in C++17
 
 // UNSUPPORTED: c++03, c++11, c++14
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 
 #include <functional>
 
-#include "test_macros.h"
-
 struct Predicate {
     typedef int argument_type;
     bool operator()(argument_type) const { return true; }
 };
 
-int main(int, char**) {
+void test() {
     std::unary_negate<Predicate> f((Predicate())); // expected-warning {{'unary_negate<Predicate>' is deprecated}}
     (void)f;
-
-  return 0;
 }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.verify.cpp

 // struct allocator_traits
 // {
 //     static constexpr pointer allocate(allocator_type& a, size_type n);
 //     ...
 // };
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-#include <cassert>
 #include <cstddef>
-#include <cstdint>
 #include <memory>
 
-#include "test_macros.h"
-
 template <class T>
-struct A
-{
+struct A {
     typedef T value_type;
-
-    value_type* allocate(std::size_t n)
-    {
-        assert(n == 12);
-        return reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xEEADBEEF));
-    }
-    value_type* allocate(std::size_t n, const void* p)
-    {
-        assert(n == 11);
-        assert(p == 0);
-        return reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xFEADBEEF));
-    }
+    value_type* allocate(std::size_t n);
+    value_type* allocate(std::size_t n, const void* p);
 };
 
-int main(int, char**)
-{
+void f() {
     A<int> a;
     std::allocator_traits<A<int> >::allocate(a, 10);          // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::allocator_traits<A<int> >::allocate(a, 10, nullptr); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.constexpr.size.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // allocator:
 // constexpr T* allocate(size_type n);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-#include <cassert>
 #include <cstddef>
 #include <memory>
 
 #include "test_macros.h"
 
 template <typename T>
 constexpr bool test()
 {
     typedef std::allocator<T> A;
     typedef std::allocator_traits<A> AT;
     A a;
     TEST_IGNORE_NODISCARD a.allocate(AT::max_size(a) + 1);           // just barely too large
     TEST_IGNORE_NODISCARD a.allocate(AT::max_size(a) * 2);           // significantly too large
     TEST_IGNORE_NODISCARD a.allocate(((size_t) -1) / sizeof(T) + 1); // multiply will overflow
     TEST_IGNORE_NODISCARD a.allocate((size_t) -1);                   // way too large
 
     return true;
 }
 
-int main(int, char**)
-{
+void f() {
     static_assert(test<double>()); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     LIBCPP_STATIC_ASSERT(test<const double>()); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-    return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // <memory>
 
 // allocator:
 // T* allocate(size_t n);
 
 #include <memory>
-#include <cassert>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+void f() {
     std::allocator<int> a;
     a.allocate(3); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
-
-    return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator_types.deprecated_in_cxx17.verify.cpp

 //     template <class U> struct rebind {typedef allocator<U> other;};
 // ...
 // };
 
 // REQUIRES: c++17
 
 #include <memory>
 
-int main(int, char**) {
+void f() {
     {
         typedef std::allocator<char>::pointer Pointer;                  // expected-warning {{'pointer' is deprecated}}
         typedef std::allocator<char>::const_pointer ConstPointer;       // expected-warning {{'const_pointer' is deprecated}}
         typedef std::allocator<char>::reference Reference;              // expected-warning {{'reference' is deprecated}}
         typedef std::allocator<char>::const_reference ConstReference;   // expected-warning {{'const_reference' is deprecated}}
         typedef std::allocator<char>::rebind<int>::other Rebind;        // expected-warning {{'rebind<int>' is deprecated}}
     }
     {
         typedef std::allocator<char const>::pointer Pointer;                  // expected-warning {{'pointer' is deprecated}}
         typedef std::allocator<char const>::const_pointer ConstPointer;       // expected-warning {{'const_pointer' is deprecated}}
         typedef std::allocator<char const>::reference Reference;              // expected-warning {{'reference' is deprecated}}
         typedef std::allocator<char const>::const_reference ConstReference;   // expected-warning {{'const_reference' is deprecated}}
         typedef std::allocator<char const>::rebind<int>::other Rebind;        // expected-warning {{'rebind<int>' is deprecated}}
     }
     {
         typedef std::allocator<void>::pointer Pointer;                  // expected-warning {{'pointer' is deprecated}}
         typedef std::allocator<void>::const_pointer ConstPointer;       // expected-warning {{'const_pointer' is deprecated}}
         // reference and const_reference are not provided by std::allocator<void>
         typedef std::allocator<void>::rebind<int>::other Rebind;        // expected-warning {{'rebind<int>' is deprecated}}
     }
-    return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator_types.removed_in_cxx20.verify.cpp

 //
 //     template <class U> struct rebind {typedef allocator<U> other;};
 // ...
 // };
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <memory>
-#include "test_macros.h"
 
 template <typename T>
 void check()
 {
     typedef typename std::allocator<T>::pointer AP;                      // expected-error 3 {{no type named 'pointer'}}
     typedef typename std::allocator<T>::const_pointer ACP;               // expected-error 3 {{no type named 'const_pointer'}}
     typedef typename std::allocator<T>::reference AR;                    // expected-error 3 {{no type named 'reference'}}
     typedef typename std::allocator<T>::const_reference ACR;             // expected-error 3 {{no type named 'const_reference'}}
     typedef typename std::allocator<T>::template rebind<int>::other ARO; // expected-error 3 {{no member named 'rebind'}}
 }
 
-int main(int, char**)
-{
+void f() {
     check<char>();
     check<char const>();
     check<void>();
-    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; }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // unique_ptr
 
 // test op*()
 
 #include <memory>
-#include <cassert>
 
-int main(int, char**) {
+#include "test_macros.h"
+
+void f() {
   std::unique_ptr<int[]> p(new int(3));
   const std::unique_ptr<int[]>& cp = p;
   TEST_IGNORE_NODISCARD(*p);  // expected-error-re {{indirection requires pointer operand ('std::unique_ptr<int{{[ ]*}}[]>' invalid)}}
   TEST_IGNORE_NODISCARD(*cp); // expected-error-re {{indirection requires pointer operand ('const std::unique_ptr<int{{[ ]*}}[]>' invalid)}}
-
-  return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // unique_ptr
 
 // test op->()
 
 #include <memory>
-#include <cassert>
 
 struct V {
   int member;
 };
 
-int main(int, char**) {
+void f() {
   std::unique_ptr<V[]> p;
   std::unique_ptr<V[]> const& cp = p;
 
   p->member; // expected-error-re {{member reference type 'std::unique_ptr<V{{[ ]*}}[]>' is not a pointer}}
              // expected-error@-1 {{no member named 'member'}}
 
   cp->member; // expected-error-re {{member reference type 'const std::unique_ptr<V{{[ ]*}}[]>' is not a pointer}}
               // expected-error@-1 {{no member named 'member'}}
-
-  return 0;
 }

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.verify.cpp

 // [utility.underlying], to_underlying
 // template <class T>
 //     constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
 
 #include <utility>
 
 struct S {};
 
-int main(int, char**) {
+void f() {
   std::to_underlying(125); // expected-error {{no matching function for call}}
   std::to_underlying(S{}); // expected-error {{no matching function for call}}
-
-  return 0;
 }

libcxx/test/support/test.support/test_macros_header.no_exceptions.verify.cpp

 // REQUIRES: no-exceptions
 
 #include "test_macros.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 #  error "TEST_HAS_NO_EXCEPTIONS should be defined"
 #endif
 
-int main(int, char**) {
+void f() {
     try { (void)0; } catch (...) { } // expected-error {{exceptions disabled}}
-    return 0;
 }

libcxx/test/support/test.support/test_macros_header.no_rtti.verify.cpp

 
 #ifndef TEST_HAS_NO_RTTI
 #  error "TEST_HAS_NO_RTTI should be defined"
 #endif
 
 struct A { virtual ~A() { } };
 struct B : A { };
 
-int main(int, char**) {
+void f() {
     A* ptr = new B;
     (void)dynamic_cast<B*>(ptr); // expected-error{{use of dynamic_cast requires -frtti}}
-    return 0;
 }