Index: cmake/Modules/CheckLibcxxAtomic.cmake
===================================================================
--- cmake/Modules/CheckLibcxxAtomic.cmake
+++ cmake/Modules/CheckLibcxxAtomic.cmake
@@ -24,7 +24,7 @@
 #include <atomic>
 std::atomic<uintptr_t> x;
 std::atomic<uintmax_t> y;
-int main() {
+int main(int, char**) {
   return x + y;
 }
 " ${varname})
Index: docs/DesignDocs/DebugMode.rst
===================================================================
--- docs/DesignDocs/DebugMode.rst
+++ docs/DesignDocs/DebugMode.rst
@@ -53,7 +53,7 @@
 
   #define _LIBCPP_DEBUG 1
   #include <string>
-  int main() {
+  int main(int, char**) {
     std::__libcpp_debug_function = std::__libcpp_throw_debug_function;
     try {
       std::string::iterator bad_it;
Index: docs/DesignDocs/FileTimeType.rst
===================================================================
--- docs/DesignDocs/FileTimeType.rst
+++ docs/DesignDocs/FileTimeType.rst
@@ -119,7 +119,7 @@
     set_file_times("/tmp/foo", new_times); // OK, supported by most FSes
   }
 
-  int main() {
+  int main(int, char**) {
     path p = "/tmp/foo";
     file_status st = status(p);
     if (!exists(st) || !is_regular_file(st))
@@ -128,6 +128,7 @@
       return 1;
     // It seems reasonable to assume this call should succeed.
     file_time_type tp = last_write_time(p); // BAD! Throws value_too_large.
+    return 0;
   }
 
 
Index: test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp
===================================================================
--- test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp
+++ test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp
@@ -39,10 +39,12 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v;
     std::random_shuffle(v.begin(), v.end());
     gen r;
     std::random_shuffle(v.begin(), v.end(), r);
+
+  return 0;
 }
Index: test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp
===================================================================
--- test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp
+++ test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp
@@ -40,10 +40,12 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     int v[1] = {1};
     std::random_shuffle(&v[0], &v[1]); // expected-error{{'random_shuffle<int *>' is deprecated}}
     gen r;
     std::random_shuffle(&v[0], &v[1], r); // expected-error{{'random_shuffle<int *, gen &>' is deprecated}}
+
+  return 0;
 }
Index: test/libcxx/algorithms/debug_less.pass.cpp
===================================================================
--- test/libcxx/algorithms/debug_less.pass.cpp
+++ test/libcxx/algorithms/debug_less.pass.cpp
@@ -210,8 +210,10 @@
     }
 }
 
-int main() {
+int main(int, char**) {
     test_passing();
     test_failing();
     test_upper_and_lower_bound();
+
+  return 0;
 }
Index: test/libcxx/algorithms/half_positive.pass.cpp
===================================================================
--- test/libcxx/algorithms/half_positive.pass.cpp
+++ test/libcxx/algorithms/half_positive.pass.cpp
@@ -28,7 +28,7 @@
 
 }  // namespace
 
-int main()
+int main(int, char**)
 {
     {
         assert(test<char>());
@@ -52,4 +52,6 @@
 #endif  // !defined(_LIBCPP_HAS_NO_INT128)
     }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/libcxx/algorithms/version.pass.cpp
===================================================================
--- test/libcxx/algorithms/version.pass.cpp
+++ test/libcxx/algorithms/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/atomics/atomics.align/align.pass.sh.cpp
===================================================================
--- test/libcxx/atomics/atomics.align/align.pass.sh.cpp
+++ test/libcxx/atomics/atomics.align/align.pass.sh.cpp
@@ -35,7 +35,7 @@
   }
 };
 
-int main() {
+int main(int, char**) {
 
 // structs and unions can't be defined in the template invocation.
 // Work around this with a typedef.
@@ -89,4 +89,6 @@
   CHECK_ALIGNMENT(struct LLIArr16 { long long int i[16]; });
   CHECK_ALIGNMENT(struct Padding { char c; /* padding */ long long int i; });
   CHECK_ALIGNMENT(union IntFloat { int i; float f; });
+
+  return 0;
 }
Index: test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
===================================================================
--- test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
+++ test/libcxx/atomics/atomics.flag/init_bool.pass.cpp
@@ -27,7 +27,7 @@
 std::atomic_flag global = ATOMIC_FLAG_INIT;
 #endif
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     assert(global.test_and_set() == 1);
@@ -40,4 +40,6 @@
         std::atomic_flag f(true);
         assert(f.test_and_set() == 1);
     }
+
+  return 0;
 }
Index: test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
===================================================================
--- test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
+++ test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp
@@ -19,7 +19,7 @@
 
 #include <atomic>
 
-int main() {
+int main(int, char**) {
     std::atomic<int> x(42);
     volatile std::atomic<int>& vx = x;
     int val1 = 1; ((void)val1);
@@ -124,4 +124,6 @@
         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;
 }
Index: test/libcxx/atomics/libcpp-has-no-threads.fail.cpp
===================================================================
--- test/libcxx/atomics/libcpp-has-no-threads.fail.cpp
+++ test/libcxx/atomics/libcpp-has-no-threads.fail.cpp
@@ -18,6 +18,8 @@
 
 #include <atomic>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/atomics/libcpp-has-no-threads.pass.cpp
===================================================================
--- test/libcxx/atomics/libcpp-has-no-threads.pass.cpp
+++ test/libcxx/atomics/libcpp-has-no-threads.pass.cpp
@@ -12,6 +12,8 @@
    'libcpp-has-no-threads' is available iff _LIBCPP_HAS_NO_THREADS is defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/atomics/version.pass.cpp
===================================================================
--- test/libcxx/atomics/version.pass.cpp
+++ test/libcxx/atomics/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/associative/map/version.pass.cpp
===================================================================
--- test/libcxx/containers/associative/map/version.pass.cpp
+++ test/libcxx/containers/associative/map/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/associative/non_const_comparator.fail.cpp
===================================================================
--- test/libcxx/containers/associative/non_const_comparator.fail.cpp
+++ test/libcxx/containers/associative/non_const_comparator.fail.cpp
@@ -22,7 +22,7 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   static_assert(!std::__invokable<BadCompare const&, int const&, int const&>::value, "");
   static_assert(std::__invokable<BadCompare&, int const&, int const&>::value, "");
 
@@ -44,4 +44,6 @@
     using C = std::multimap<long, int, BadCompare>;
     C s;
   }
+
+  return 0;
 }
Index: test/libcxx/containers/associative/set/version.pass.cpp
===================================================================
--- test/libcxx/containers/associative/set/version.pass.cpp
+++ test/libcxx/containers/associative/set/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
===================================================================
--- test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
+++ test/libcxx/containers/associative/tree_balance_after_insert.pass.cpp
@@ -1608,11 +1608,13 @@
     assert(h.__is_black_ == true);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
     test5();
+
+  return 0;
 }
Index: test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
===================================================================
--- test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
+++ test/libcxx/containers/associative/tree_key_value_traits.pass.cpp
@@ -53,6 +53,8 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   testKeyValueTrait();
+
+  return 0;
 }
Index: test/libcxx/containers/associative/tree_left_rotate.pass.cpp
===================================================================
--- test/libcxx/containers/associative/tree_left_rotate.pass.cpp
+++ test/libcxx/containers/associative/tree_left_rotate.pass.cpp
@@ -93,8 +93,10 @@
     assert(c.__right_ == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/libcxx/containers/associative/tree_remove.pass.cpp
===================================================================
--- test/libcxx/containers/associative/tree_remove.pass.cpp
+++ test/libcxx/containers/associative/tree_remove.pass.cpp
@@ -1641,10 +1641,12 @@
     assert(root.__is_black_ == false);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
+
+  return 0;
 }
Index: test/libcxx/containers/associative/tree_right_rotate.pass.cpp
===================================================================
--- test/libcxx/containers/associative/tree_right_rotate.pass.cpp
+++ test/libcxx/containers/associative/tree_right_rotate.pass.cpp
@@ -93,8 +93,10 @@
     assert(c.__right_ == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/libcxx/containers/associative/undef_min_max.pass.cpp
===================================================================
--- test/libcxx/containers/associative/undef_min_max.pass.cpp
+++ test/libcxx/containers/associative/undef_min_max.pass.cpp
@@ -15,7 +15,9 @@
 
 #include <map>
 
-int main() {
+int main(int, char**) {
   std::map<int, int> m;
   ((void)m);
+
+  return 0;
 }
Index: test/libcxx/containers/container.adaptors/queue/version.pass.cpp
===================================================================
--- test/libcxx/containers/container.adaptors/queue/version.pass.cpp
+++ test/libcxx/containers/container.adaptors/queue/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/container.adaptors/stack/version.pass.cpp
===================================================================
--- test/libcxx/containers/container.adaptors/stack/version.pass.cpp
+++ test/libcxx/containers/container.adaptors/stack/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
===================================================================
--- test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
+++ test/libcxx/containers/gnu_cxx/hash_map.pass.cpp
@@ -17,9 +17,11 @@
 template class hash_map<int, int>;
 }
 
-int main() {
+int main(int, char**) {
   typedef __gnu_cxx::hash_map<int, int> Map;
   Map m;
   Map m2(m);
   ((void)m2);
+
+  return 0;
 }
Index: test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
===================================================================
--- test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
+++ test/libcxx/containers/gnu_cxx/hash_set.pass.cpp
@@ -17,9 +17,11 @@
 template class hash_set<int>;
 }
 
-int main() {
+int main(int, char**) {
   typedef __gnu_cxx::hash_set<int> Set;
   Set s;
   Set s2(s);
   ((void)s2);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp
+++ test/libcxx/containers/sequences/array/array.zero/db_back.pass.cpp
@@ -29,7 +29,7 @@
   return false;
 }
 
-int main()
+int main(int, char**)
 {
   {
     typedef std::array<int, 0> C;
@@ -45,4 +45,6 @@
     assert(CheckDebugThrows(c));
     assert(CheckDebugThrows(cc));
   }
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp
+++ test/libcxx/containers/sequences/array/array.zero/db_front.pass.cpp
@@ -29,7 +29,7 @@
   return false;
 }
 
-int main()
+int main(int, char**)
 {
   {
     typedef std::array<int, 0> C;
@@ -45,4 +45,6 @@
     assert(CheckDebugThrows(c));
     assert(CheckDebugThrows(cc));
   }
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp
+++ test/libcxx/containers/sequences/array/array.zero/db_indexing.pass.cpp
@@ -29,7 +29,7 @@
   return false;
 }
 
-int main()
+int main(int, char**)
 {
   {
     typedef std::array<int, 0> C;
@@ -49,4 +49,6 @@
     assert(CheckDebugThrows(cc, 0));
     assert(CheckDebugThrows(cc, 1));
   }
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/array/version.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/array/version.pass.cpp
+++ test/libcxx/containers/sequences/array/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/deque/incomplete.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/deque/incomplete.pass.cpp
+++ test/libcxx/containers/sequences/deque/incomplete.pass.cpp
@@ -22,10 +22,12 @@
   std::deque<A>::reverse_iterator it2;
 };
 
-int main()
+int main(int, char**)
 {
   A a;
   assert(a.d.size() == 0);
   a.it = a.d.begin();
   a.it2 = a.d.rend();
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp
+++ test/libcxx/containers/sequences/deque/pop_back_empty.pass.cpp
@@ -16,10 +16,12 @@
 #include <deque>
 
 
-int main() {
+int main(int, char**) {
     std::deque<int> q;
     q.push_back(0);
     q.pop_back();
     q.pop_back();
     std::exit(1);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/deque/version.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/deque/version.pass.cpp
+++ test/libcxx/containers/sequences/deque/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/forwardlist/version.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/forwardlist/version.pass.cpp
+++ test/libcxx/containers/sequences/forwardlist/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
+++ test/libcxx/containers/sequences/list/list.cons/db_copy.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::list<int> l1;
     l1.push_back(1); l1.push_back(2); l1.push_back(3);
@@ -27,4 +27,6 @@
     std::list<int> l2 = l1;
     l2.erase(i);
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
+++ test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp
@@ -25,10 +25,12 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::list<int> l1 = {1, 2, 3};
     std::list<int>::iterator i = l1.begin();
     std::list<int> l2 = std::move(l1);
     assert(*l2.erase(i) == 2);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp
@@ -37,10 +37,12 @@
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     std::list<A> c1;
     std::list<A> c2;
     std::list<A>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
@@ -20,11 +20,13 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
@@ -28,4 +28,6 @@
     std::list<int>::const_iterator i = l2.begin();
     l1.erase(i);
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
@@ -20,12 +20,14 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
     assert(false);
+
+  return 0;
 }
 
Index: test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
@@ -20,11 +20,13 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
@@ -20,11 +20,13 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
@@ -20,10 +20,12 @@
 #include <cassert>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
@@ -23,7 +23,7 @@
 #include <cassert>
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> v(100);
@@ -35,4 +35,6 @@
                                        input_iterator<const int*>(a+N));
         assert(false);
     }
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
@@ -20,10 +20,12 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::list<int> v1(3);
     std::list<int> v2(3);
     v1.insert(v2.begin(), 4);
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp
@@ -20,10 +20,12 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::list<int> c1(100);
     std::list<int> c2;
     std::list<int>::iterator i = c1.insert(next(c2.cbegin(), 10), 5, 1);
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_db1.pass.cpp
@@ -21,11 +21,13 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
     std::list<int> v1(3);
     std::list<int> v2(3);
     int i = 4;
     v1.insert(v2.begin(), i);
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
+++ test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp
@@ -20,7 +20,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = {1, 2, 3};
     std::list<int> c(a, a+3);
@@ -32,4 +32,6 @@
     assert(c.empty());
     c.pop_back(); // operation under test
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
+++ test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.pass.cpp
@@ -20,7 +20,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> v1(3);
@@ -28,4 +28,6 @@
         v1.splice(v2.begin(), v2);
         assert(false);
     }
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
+++ test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp
@@ -20,7 +20,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> v1(3);
@@ -28,4 +28,6 @@
         v1.splice(v1.begin(), v2, v1.begin());
         assert(false);
     }
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
+++ test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp
@@ -20,7 +20,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> v1(3);
@@ -28,4 +28,6 @@
         v1.splice(v1.begin(), v2, v2.begin(), v1.end());
         assert(false);
     }
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/list/version.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/list/version.pass.cpp
+++ test/libcxx/containers/sequences/list/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/vector/asan.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/asan.pass.cpp
+++ test/libcxx/containers/sequences/vector/asan.pass.cpp
@@ -28,7 +28,7 @@
   exit(0);
 }
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -68,5 +68,5 @@
     }
 }
 #else
-int main () { return 0; }
+int main(int, char**) { return 0; }
 #endif
Index: test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
+++ test/libcxx/containers/sequences/vector/asan_throw.pass.cpp
@@ -219,7 +219,7 @@
   assert(is_contiguous_container_asan_correct(v));
 }
 
-int main() {
+int main(int, char**) {
   test_push_back();
   test_emplace_back();
   test_insert_range();
@@ -230,4 +230,6 @@
   test_insert_n2();
   test_resize();
   test_resize_param();
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
+++ test/libcxx/containers/sequences/vector/const_value_type.pass.cpp
@@ -15,7 +15,9 @@
 #include <vector>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::vector<const int> v = {1, 2, 3};
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/vector/db_back.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_back.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_back.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_cback.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_cback.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_cback.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -45,8 +45,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_cfront.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -45,8 +45,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_cindex.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -47,8 +47,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_front.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_front.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_front.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_index.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_index.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_index.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -47,8 +47,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -47,8 +47,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -53,8 +53,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -51,8 +51,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -51,8 +51,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
+++ test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -47,8 +47,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp
+++ test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp
@@ -16,10 +16,12 @@
 #include <vector>
 
 
-int main() {
+int main(int, char**) {
     std::vector<int> v;
     v.push_back(0);
     v.pop_back();
     v.pop_back();
     std::exit(1);
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -48,6 +48,8 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_under_alloc();
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ test/libcxx/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -51,6 +51,8 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_under_alloc();
+
+  return 0;
 }
Index: test/libcxx/containers/sequences/vector/version.pass.cpp
===================================================================
--- test/libcxx/containers/sequences/vector/version.pass.cpp
+++ test/libcxx/containers/sequences/vector/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/unord/key_value_traits.pass.cpp
===================================================================
--- test/libcxx/containers/unord/key_value_traits.pass.cpp
+++ test/libcxx/containers/unord/key_value_traits.pass.cpp
@@ -53,6 +53,8 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   testKeyValueTrait();
+
+  return 0;
 }
Index: test/libcxx/containers/unord/next_pow2.pass.cpp
===================================================================
--- test/libcxx/containers/unord/next_pow2.pass.cpp
+++ test/libcxx/containers/unord/next_pow2.pass.cpp
@@ -74,7 +74,7 @@
     assert(m.bucket_count() >= num_reserve2);
 }
 
-int main()
+int main(int, char**)
 {
     test_next_pow2();
 
Index: test/libcxx/containers/unord/next_prime.pass.cpp
===================================================================
--- test/libcxx/containers/unord/next_prime.pass.cpp
+++ test/libcxx/containers/unord/next_prime.pass.cpp
@@ -36,7 +36,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     assert(std::__next_prime(0) == 0);
     for (std::size_t n = 1; n <= 100000; ++n)
@@ -47,4 +47,6 @@
             assert(!is_prime(i));
         assert(is_prime(p));
     }
+
+  return 0;
 }
Index: test/libcxx/containers/unord/non_const_comparator.fail.cpp
===================================================================
--- test/libcxx/containers/unord/non_const_comparator.fail.cpp
+++ test/libcxx/containers/unord/non_const_comparator.fail.cpp
@@ -29,7 +29,7 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   static_assert(!std::__invokable<BadEqual const&, int const&, int const&>::value, "");
   static_assert(std::__invokable<BadEqual&, int const&, int const&>::value, "");
 
@@ -54,4 +54,6 @@
     using C = std::unordered_multimap<long, int, BadHash, BadEqual>;
     C s;
   }
+
+  return 0;
 }
Index: test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
===================================================================
--- test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
+++ test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, std::string> C;
@@ -53,8 +53,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
===================================================================
--- test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
+++ test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, std::string> C;
@@ -49,8 +49,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
===================================================================
--- test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
+++ test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, std::string> C;
@@ -50,8 +50,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
===================================================================
--- test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
+++ test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, std::string> C;
@@ -47,8 +47,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/containers/unord/unord.map/version.pass.cpp
===================================================================
--- test/libcxx/containers/unord/unord.map/version.pass.cpp
+++ test/libcxx/containers/unord/unord.map/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
===================================================================
--- test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
+++ test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
@@ -42,7 +42,7 @@
   size_t operator()(T const&) const { return 0; }
 };
 
-int main() {
+int main(int, char**) {
 
   {
     using Set = std::unordered_set<VT>;
@@ -66,4 +66,6 @@
     using Set = std::unordered_set<int, GoodHashNoDefault>;
     Set s(/*bucketcount*/42, GoodHashNoDefault(nullptr));
   }
+
+  return 0;
 }
Index: test/libcxx/containers/unord/unord.set/version.pass.cpp
===================================================================
--- test/libcxx/containers/unord/unord.set/version.pass.cpp
+++ test/libcxx/containers/unord/unord.set/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/debug/containers/db_associative_container_tests.pass.cpp
===================================================================
--- test/libcxx/debug/containers/db_associative_container_tests.pass.cpp
+++ test/libcxx/debug/containers/db_associative_container_tests.pass.cpp
@@ -51,7 +51,7 @@
   // FIXME Add tests here
 };
 
-int main()
+int main(int, char**)
 {
   using SetAlloc = test_allocator<int>;
   using MapAlloc = test_allocator<std::pair<const int, int>>;
@@ -66,4 +66,6 @@
     AssociativeContainerChecks<
         std::multimap<int, int, std::less<int>, MapAlloc>, CT_MultiMap>::run();
   }
+
+  return 0;
 }
Index: test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp
===================================================================
--- test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp
+++ test/libcxx/debug/containers/db_sequence_container_iterators.pass.cpp
@@ -307,7 +307,7 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
   using Alloc = test_allocator<int>;
   {
@@ -323,4 +323,6 @@
     SequenceContainerChecks<
         std::deque<int, Alloc>, CT_Deque>::run();
   }
+
+  return 0;
 }
Index: test/libcxx/debug/containers/db_string.pass.cpp
===================================================================
--- test/libcxx/debug/containers/db_string.pass.cpp
+++ test/libcxx/debug/containers/db_string.pass.cpp
@@ -93,7 +93,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
   StringContainerChecks<>::run();
+
+  return 0;
 }
Index: test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
===================================================================
--- test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
+++ test/libcxx/debug/containers/db_unord_container_tests.pass.cpp
@@ -49,7 +49,7 @@
 
 };
 
-int main()
+int main(int, char**)
 {
   using SetAlloc = test_allocator<int>;
   using MapAlloc = test_allocator<std::pair<const int, int>>;
@@ -67,4 +67,6 @@
         std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, SetAlloc>,
         CT_UnorderedMultiSet>::run();
   }
+
+  return 0;
 }
Index: test/libcxx/debug/debug_abort.pass.cpp
===================================================================
--- test/libcxx/debug/debug_abort.pass.cpp
+++ test/libcxx/debug/debug_abort.pass.cpp
@@ -27,7 +27,7 @@
     std::_Exit(EXIT_FAILURE);
 }
 
-int main()
+int main(int, char**)
 {
   if (std::signal(SIGABRT, signal_handler) != SIG_ERR)
     _LIBCPP_ASSERT(false, "foo");
Index: test/libcxx/debug/debug_throw.pass.cpp
===================================================================
--- test/libcxx/debug/debug_throw.pass.cpp
+++ test/libcxx/debug/debug_throw.pass.cpp
@@ -23,7 +23,7 @@
 #include <type_traits>
 #include <__debug>
 
-int main()
+int main(int, char**)
 {
   {
     std::__libcpp_debug_function = std::__libcpp_throw_debug_function;
@@ -37,4 +37,6 @@
                                   std::__libcpp_debug_exception
                   >::value), "must be an exception");
   }
+
+  return 0;
 }
Index: test/libcxx/debug/debug_throw_register.pass.cpp
===================================================================
--- test/libcxx/debug/debug_throw_register.pass.cpp
+++ test/libcxx/debug/debug_throw_register.pass.cpp
@@ -26,10 +26,12 @@
 #include <__debug>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
   try {
     _LIBCPP_ASSERT(false, "foo");
     assert(false);
   } catch (...) {}
+
+  return 0;
 }
Index: test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp
===================================================================
--- test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp
+++ test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp
@@ -22,7 +22,9 @@
 #include <memory>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::auto_ptr<int> p;
+
+  return 0;
 }
Index: test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp
===================================================================
--- test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp
+++ test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp
@@ -30,9 +30,11 @@
 #include <memory>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::auto_ptr<int> AP; // expected-error{{'auto_ptr<int>' is deprecated}}
     typedef std::auto_ptr<void> APV; // expected-error{{'auto_ptr<void>' is deprecated}}
     typedef std::auto_ptr_ref<int> APR; // expected-error{{'auto_ptr_ref<int>' is deprecated}}
+
+  return 0;
 }
Index: test/libcxx/depr/depr.c.headers/ciso646.pass.cpp
===================================================================
--- test/libcxx/depr/depr.c.headers/ciso646.pass.cpp
+++ test/libcxx/depr/depr.c.headers/ciso646.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
===================================================================
--- test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
+++ test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
@@ -14,8 +14,10 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::complex<double> d;
     (void)d;
+
+  return 0;
 }
Index: test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
===================================================================
--- test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
+++ test/libcxx/depr/depr.c.headers/extern_c.pass.cpp
@@ -39,4 +39,6 @@
 #include <wctype.h>
 }
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/depr/depr.c.headers/locale_h.pass.cpp
===================================================================
--- test/libcxx/depr/depr.c.headers/locale_h.pass.cpp
+++ test/libcxx/depr/depr.c.headers/locale_h.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
===================================================================
--- test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
+++ test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -14,10 +14,12 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::complex<double> cd;
     (void)cd;
     double x = sin(1.0);
     (void)x; // to placate scan-build
+
+  return 0;
 }
Index: test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp
===================================================================
--- test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp
+++ test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp
@@ -31,7 +31,7 @@
     int identity(int v) { return v; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, int> PUF; // expected-error{{'pointer_to_unary_function<int, int>' is deprecated}}
     typedef std::pointer_to_binary_function<int, int, int> PBF; // expected-error{{'pointer_to_binary_function<int, int, int>' is deprecated}}
@@ -55,4 +55,6 @@
     std::mem_fun_ref<int, Foo, int>(&Foo::identity); // expected-error{{'mem_fun_ref<int, Foo, int>' is deprecated}}
     std::mem_fun_ref<int, Foo>(&Foo::const_zero); // expected-error{{'mem_fun_ref<int, Foo>' is deprecated}}
     std::mem_fun_ref<int, Foo, int>(&Foo::const_identity); // expected-error{{'mem_fun_ref<int, Foo, int>' is deprecated}}
+
+  return 0;
 }
Index: test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
===================================================================
--- test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
+++ test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
@@ -30,7 +30,7 @@
   int sum(int a, int b) const { return a + b; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, int> PUF;
     typedef std::pointer_to_binary_function<int, int, int> PBF;
@@ -60,4 +60,6 @@
 
     assert((std::mem_fun_ref(&Foo::zero)(f) == 0));
     assert((std::mem_fun_ref(&Foo::identity)(f, 5) == 5));
+
+  return 0;
 }
Index: test/libcxx/depr/depr.str.strstreams/version.pass.cpp
===================================================================
--- test/libcxx/depr/depr.str.strstreams/version.pass.cpp
+++ test/libcxx/depr/depr.str.strstreams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/depr/enable_removed_cpp17_features.pass.cpp
===================================================================
--- test/libcxx/depr/enable_removed_cpp17_features.pass.cpp
+++ test/libcxx/depr/enable_removed_cpp17_features.pass.cpp
@@ -21,5 +21,7 @@
 #error _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR must be defined
 #endif
 
-int main() {
+int main(int, char**) {
+
+  return 0;
 }
Index: test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp
===================================================================
--- test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp
+++ test/libcxx/depr/exception.unexpected/get_unexpected.pass.cpp
@@ -23,7 +23,7 @@
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
 
     std::unexpected_handler old = std::get_unexpected();
@@ -38,4 +38,6 @@
     std::set_terminate(f3);
     (*old)();
     assert(0);
+
+  return 0;
 }
Index: test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp
===================================================================
--- test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp
+++ test/libcxx/depr/exception.unexpected/set_unexpected.pass.cpp
@@ -22,7 +22,7 @@
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::unexpected_handler old = std::set_unexpected(f1);
     // verify there is a previous unexpected handler
@@ -33,4 +33,6 @@
     std::set_terminate(f3);
     (*old)();
     assert(0);
+
+  return 0;
 }
Index: test/libcxx/depr/exception.unexpected/unexpected.pass.cpp
===================================================================
--- test/libcxx/depr/exception.unexpected/unexpected.pass.cpp
+++ test/libcxx/depr/exception.unexpected/unexpected.pass.cpp
@@ -19,9 +19,11 @@
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_unexpected(fexit);
     std::unexpected();
     assert(false);
+
+  return 0;
 }
Index: test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp
===================================================================
--- test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp
+++ test/libcxx/depr/exception.unexpected/unexpected_disabled_cpp17.fail.cpp
@@ -14,9 +14,11 @@
 
 void f() {}
 
-int main() {
+int main(int, char**) {
   using T = std::unexpected_handler; // expected-error {{no type named 'unexpected_handler' in namespace 'std'}}
   std::unexpected(); // expected-error {{no member named 'unexpected' in namespace 'std'}}
   std::get_unexpected(); // expected-error {{no member named 'get_unexpected' in namespace 'std'}}
   std::set_unexpected(f); // expected-error {{no type named 'set_unexpected' in namespace 'std'}}
+
+  return 0;
 }
Index: test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
===================================================================
--- test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
+++ test/libcxx/diagnostics/assertions/version_cassert.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/diagnostics/enable_nodiscard.fail.cpp
===================================================================
--- test/libcxx/diagnostics/enable_nodiscard.fail.cpp
+++ test/libcxx/diagnostics/enable_nodiscard.fail.cpp
@@ -24,9 +24,11 @@
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
 
-int main() {
+int main(int, char**) {
   foo(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   bar(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   (void)foo(); // OK. void casts disable the diagnostic.
   (void)bar();
+
+  return 0;
 }
Index: test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp
===================================================================
--- test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp
+++ test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp
@@ -25,8 +25,10 @@
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
 
-int main() {
+int main(int, char**) {
   foo(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   bar(); // OK.
   (void)foo(); // OK.
+
+  return 0;
 }
Index: test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp
===================================================================
--- test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp
+++ test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp
@@ -23,8 +23,10 @@
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
 
-int main() {
+int main(int, char**) {
   bar(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   foo(); // OK.
   (void)bar(); // OK.
+
+  return 0;
 }
Index: test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
===================================================================
--- test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
+++ test/libcxx/diagnostics/errno/version_cerrno.pass.cpp
@@ -15,4 +15,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/diagnostics/nodiscard.pass.cpp
===================================================================
--- test/libcxx/diagnostics/nodiscard.pass.cpp
+++ test/libcxx/diagnostics/nodiscard.pass.cpp
@@ -14,6 +14,8 @@
 
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 
-int main() {
+int main(int, char**) {
   foo(); // OK.
+
+  return 0;
 }
Index: test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp
===================================================================
--- test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp
+++ test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp
@@ -16,7 +16,9 @@
 
 _LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
 
-int main ()
+int main(int, char**)
 {
 	foo();	// expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp
===================================================================
--- test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp
+++ test/libcxx/diagnostics/nodiscard_aftercxx17.pass.cpp
@@ -16,7 +16,9 @@
 
 _LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
 
-int main ()
+int main(int, char**)
 {
 	foo();	// no error here!
+
+  return 0;
 }
Index: test/libcxx/diagnostics/nodiscard_extensions.fail.cpp
===================================================================
--- test/libcxx/diagnostics/nodiscard_extensions.fail.cpp
+++ test/libcxx/diagnostics/nodiscard_extensions.fail.cpp
@@ -26,9 +26,11 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
     std::get_temporary_buffer<int>(1);
   }
+
+  return 0;
 }
Index: test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
===================================================================
--- test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
+++ test/libcxx/diagnostics/nodiscard_extensions.pass.cpp
@@ -21,8 +21,10 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     std::get_temporary_buffer<int>(1); // intentional memory leak.
   }
+
+  return 0;
 }
Index: test/libcxx/diagnostics/std.exceptions/version.pass.cpp
===================================================================
--- test/libcxx/diagnostics/std.exceptions/version.pass.cpp
+++ test/libcxx/diagnostics/std.exceptions/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/diagnostics/syserr/version.pass.cpp
===================================================================
--- test/libcxx/diagnostics/syserr/version.pass.cpp
+++ test/libcxx/diagnostics/syserr/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/double_include.sh.cpp
===================================================================
--- test/libcxx/double_include.sh.cpp
+++ test/libcxx/double_include.sh.cpp
@@ -168,5 +168,5 @@
 #include <ext/hash_set>
 
 #if defined(WITH_MAIN)
-int main() {}
+int main(int, char**) { return 0; }
 #endif
Index: test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp
===================================================================
--- test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp
+++ test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp
@@ -14,6 +14,8 @@
 #  error "<experimental/algorithm> must include <algorithm>"
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/algorithms/version.pass.cpp
===================================================================
--- test/libcxx/experimental/algorithms/version.pass.cpp
+++ test/libcxx/experimental/algorithms/version.pass.cpp
@@ -14,6 +14,8 @@
 #  error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
===================================================================
--- test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
+++ test/libcxx/experimental/diagnostics/syserr/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/system_error:* {{"<experimental/system_error> has been removed. Use <system_error> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
===================================================================
--- test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
+++ test/libcxx/experimental/diagnostics/syserr/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/filesystem/version.pass.cpp
===================================================================
--- test/libcxx/experimental/filesystem/version.pass.cpp
+++ test/libcxx/experimental/filesystem/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp
===================================================================
--- test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp
+++ test/libcxx/experimental/language.support/support.coroutines/dialect_support.sh.cpp
@@ -49,10 +49,12 @@
   co_return;
 }
 
-int main()
+int main(int, char**)
 {
   MyFuture f = test_coro();
   while (!f.p.done())
     f.p.resume();
   f.p.destroy();
+
+  return 0;
 }
Index: test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp
===================================================================
--- test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp
+++ test/libcxx/experimental/language.support/support.coroutines/version.sh.cpp
@@ -19,6 +19,8 @@
 #error _LIBCPP_VERSION must be defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
+++ test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
@@ -103,7 +103,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         using T = CountCopies;
@@ -167,4 +167,6 @@
         assert(p.first.alloc == h.M);
         assert(p.second.count == 2);
     }
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
+++ test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp
@@ -26,7 +26,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using Alloc = ex::polymorphic_allocator<int>;
     using Traits = std::allocator_traits<Alloc>;
@@ -38,4 +38,6 @@
     assert(AssertCount == 0);
     a.deallocate(nullptr, maxSize + 1);
     assert(AssertCount == 1);
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp
@@ -26,7 +26,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using Alloc = NullAllocator<char>;
 
@@ -41,4 +41,6 @@
     assert(AssertCount == 0);
     m1.deallocate(nullptr, maxSize + 1);
     assert(AssertCount >= 1);
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_deque_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_forward_list_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_list_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_map_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_set_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_string_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_map_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_unordered_set_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.aliases/header_vector_libcpp_version.pass.cpp
@@ -16,6 +16,8 @@
 #error header must provide _LIBCPP_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp
@@ -53,8 +53,10 @@
 POSType constructed_after_resources(resource, resource->allocate(1024), 1024);
 POSType constructed_after_resources2(nullptr, resource->allocate(1024), 1024);
 
-int main()
+int main(int, char**)
 {
     swap(constructed_after_resources, constructed_before_resources);
     swap(constructed_before_resources2, constructed_after_resources2);
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp
@@ -46,7 +46,9 @@
 
 POSType constructed_after_resources(resource, resource->allocate(1024), 1024);
 
-int main()
+int main(int, char**)
 {
     swap(constructed_after_resources, constructed_before_resources);
+
+  return 0;
 }
Index: test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
===================================================================
--- test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
+++ test/libcxx/experimental/memory/memory.resource.synop/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
===================================================================
--- test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
+++ test/libcxx/experimental/numerics/numeric.ops/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/numeric:* {{"<experimental/numeric> has been removed. Use <numeric> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
===================================================================
--- test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
+++ test/libcxx/experimental/numerics/numeric.ops/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
===================================================================
--- test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
+++ test/libcxx/experimental/strings/string.view/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/string_view:* {{"<experimental/string_view> has been removed. Use <string_view> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/strings/string.view/version.pass.cpp
===================================================================
--- test/libcxx/experimental/strings/string.view/version.pass.cpp
+++ test/libcxx/experimental/strings/string.view/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
===================================================================
--- test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
+++ test/libcxx/experimental/utilities/any/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/any:* {{"<experimental/any> has been removed. Use <any> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/any/version.pass.cpp
===================================================================
--- test/libcxx/experimental/utilities/any/version.pass.cpp
+++ test/libcxx/experimental/utilities/any/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/meta/version.pass.cpp
===================================================================
--- test/libcxx/experimental/utilities/meta/version.pass.cpp
+++ test/libcxx/experimental/utilities/meta/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
===================================================================
--- test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
+++ test/libcxx/experimental/utilities/optional/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/optional:* {{"<experimental/optional> has been removed. Use <optional> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/optional/version.pass.cpp
===================================================================
--- test/libcxx/experimental/utilities/optional/version.pass.cpp
+++ test/libcxx/experimental/utilities/optional/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
===================================================================
--- test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
+++ test/libcxx/experimental/utilities/ratio/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/ratio:* {{"<experimental/ratio> has been removed. Use <ratio> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/ratio/version.pass.cpp
===================================================================
--- test/libcxx/experimental/utilities/ratio/version.pass.cpp
+++ test/libcxx/experimental/utilities/ratio/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
===================================================================
--- test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
+++ test/libcxx/experimental/utilities/time/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/chrono:* {{"<experimental/chrono> has been removed. Use <chrono> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/time/version.pass.cpp
===================================================================
--- test/libcxx/experimental/utilities/time/version.pass.cpp
+++ test/libcxx/experimental/utilities/time/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
===================================================================
--- test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
+++ test/libcxx/experimental/utilities/tuple/use_header_warning.fail.cpp
@@ -14,4 +14,6 @@
 
 // expected-error@experimental/tuple:* {{"<experimental/tuple> has been removed. Use <tuple> instead."}}
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/tuple/version.pass.cpp
===================================================================
--- test/libcxx/experimental/utilities/tuple/version.pass.cpp
+++ test/libcxx/experimental/utilities/tuple/version.pass.cpp
@@ -17,4 +17,6 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/experimental/utilities/utility/version.pass.cpp
===================================================================
--- test/libcxx/experimental/utilities/utility/version.pass.cpp
+++ test/libcxx/experimental/utilities/utility/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/extensions/hash/specializations.fail.cpp
===================================================================
--- test/libcxx/extensions/hash/specializations.fail.cpp
+++ test/libcxx/extensions/hash/specializations.fail.cpp
@@ -10,7 +10,9 @@
 #include <ext/hash_map>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     assert(__gnu_cxx::hash<std::string>()(std::string()) == 0);  // error
+
+  return 0;
 }
Index: test/libcxx/extensions/hash/specializations.pass.cpp
===================================================================
--- test/libcxx/extensions/hash/specializations.pass.cpp
+++ test/libcxx/extensions/hash/specializations.pass.cpp
@@ -12,7 +12,7 @@
 #include <ext/hash_map>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     char str[] = "test";
     assert(__gnu_cxx::hash<const char *>()("test") ==
@@ -27,4 +27,6 @@
     assert(__gnu_cxx::hash<unsigned int>()(42) == 42);
     assert(__gnu_cxx::hash<long>()(42) == 42);
     assert(__gnu_cxx::hash<unsigned long>()(42) == 42);
+
+  return 0;
 }
Index: test/libcxx/extensions/hash_map/const_iterator.fail.cpp
===================================================================
--- test/libcxx/extensions/hash_map/const_iterator.fail.cpp
+++ test/libcxx/extensions/hash_map/const_iterator.fail.cpp
@@ -8,10 +8,12 @@
 
 #include <ext/hash_map>
 
-int main()
+int main(int, char**)
 {
     __gnu_cxx::hash_map<int, int> m;
     m[1] = 1;
     const __gnu_cxx::hash_map<int, int> &cm = m;
     cm.find(1)->second = 2;  // error
+
+  return 0;
 }
Index: test/libcxx/extensions/nothing_to_do.pass.cpp
===================================================================
--- test/libcxx/extensions/nothing_to_do.pass.cpp
+++ test/libcxx/extensions/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/fuzzing/nth_element.cpp
===================================================================
--- test/libcxx/fuzzing/nth_element.cpp
+++ test/libcxx/fuzzing/nth_element.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/partial_sort.cpp
===================================================================
--- test/libcxx/fuzzing/partial_sort.cpp
+++ test/libcxx/fuzzing/partial_sort.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/partial_sort_copy.cpp
===================================================================
--- test/libcxx/fuzzing/partial_sort_copy.cpp
+++ test/libcxx/fuzzing/partial_sort_copy.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/partition.cpp
===================================================================
--- test/libcxx/fuzzing/partition.cpp
+++ test/libcxx/fuzzing/partition.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/partition_copy.cpp
===================================================================
--- test/libcxx/fuzzing/partition_copy.cpp
+++ test/libcxx/fuzzing/partition_copy.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/regex_ECMAScript.cpp
===================================================================
--- test/libcxx/fuzzing/regex_ECMAScript.cpp
+++ test/libcxx/fuzzing/regex_ECMAScript.cpp
@@ -24,7 +24,7 @@
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/regex_POSIX.cpp
===================================================================
--- test/libcxx/fuzzing/regex_POSIX.cpp
+++ test/libcxx/fuzzing/regex_POSIX.cpp
@@ -24,7 +24,7 @@
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/regex_awk.cpp
===================================================================
--- test/libcxx/fuzzing/regex_awk.cpp
+++ test/libcxx/fuzzing/regex_awk.cpp
@@ -24,7 +24,7 @@
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/regex_egrep.cpp
===================================================================
--- test/libcxx/fuzzing/regex_egrep.cpp
+++ test/libcxx/fuzzing/regex_egrep.cpp
@@ -24,7 +24,7 @@
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/regex_extended.cpp
===================================================================
--- test/libcxx/fuzzing/regex_extended.cpp
+++ test/libcxx/fuzzing/regex_extended.cpp
@@ -24,7 +24,7 @@
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/regex_grep.cpp
===================================================================
--- test/libcxx/fuzzing/regex_grep.cpp
+++ test/libcxx/fuzzing/regex_grep.cpp
@@ -24,7 +24,7 @@
 
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/sort.cpp
===================================================================
--- test/libcxx/fuzzing/sort.cpp
+++ test/libcxx/fuzzing/sort.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/stable_partition.cpp
===================================================================
--- test/libcxx/fuzzing/stable_partition.cpp
+++ test/libcxx/fuzzing/stable_partition.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/stable_sort.cpp
===================================================================
--- test/libcxx/fuzzing/stable_sort.cpp
+++ test/libcxx/fuzzing/stable_sort.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/unique.cpp
===================================================================
--- test/libcxx/fuzzing/unique.cpp
+++ test/libcxx/fuzzing/unique.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/fuzzing/unique_copy.cpp
===================================================================
--- test/libcxx/fuzzing/unique_copy.cpp
+++ test/libcxx/fuzzing/unique_copy.cpp
@@ -25,7 +25,7 @@
 const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
 
 
-int main ()
+int main(int, char**)
 {
 	for (size_t i = 0; i < k_num_tests; ++i)
 		{
Index: test/libcxx/include_as_c.sh.cpp
===================================================================
--- test/libcxx/include_as_c.sh.cpp
+++ test/libcxx/include_as_c.sh.cpp
@@ -33,4 +33,8 @@
 #include <wchar.h>
 #include <wctype.h>
 
-int main() {}
+int main(int argc, char **argv) {
+  (void)argc;
+  (void)argv;
+  return 0;
+}
Index: test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp
===================================================================
--- test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp
+++ test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/fopen.fail.cpp
@@ -10,7 +10,9 @@
 
 #include <cstdio>
 
-int main() {
+int main(int, char**) {
     // fopen is not available on systems without a global filesystem namespace.
     std::fopen("", "");
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp
===================================================================
--- test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp
+++ test/libcxx/input.output/file.streams/c.files/no.global.filesystem.namespace/rename.fail.cpp
@@ -10,7 +10,9 @@
 
 #include <cstdio>
 
-int main() {
+int main(int, char**) {
     // rename is not available on systems without a global filesystem namespace.
     std::rename("", "");
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
+++ test/libcxx/input.output/file.streams/c.files/version_ccstdio.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
+++ test/libcxx/input.output/file.streams/c.files/version_cinttypes.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp
+++ test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp
@@ -15,9 +15,11 @@
 
 #include <fstream>
 
-int main()
+int main(int, char**)
 {
 	std::basic_filebuf<char, std::char_traits<wchar_t> > f;
 //  expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+
+  return 0;
 }
 
Index: test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
+++ test/libcxx/input.output/file.streams/fstreams/fstream.close.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
 
@@ -31,4 +31,6 @@
     assert(!ofs.good());
 
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp
+++ test/libcxx/input.output/file.streams/fstreams/fstream.cons/wchar_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
@@ -42,4 +42,6 @@
     }
     _wremove(temp.c_str());
 #endif
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp
+++ test/libcxx/input.output/file.streams/fstreams/fstream.members/open_wchar_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
@@ -48,4 +48,6 @@
     }
     _wremove(temp.c_str());
 #endif
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp
+++ test/libcxx/input.output/file.streams/fstreams/ifstream.cons/wchar_pointer.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     {
@@ -38,4 +38,6 @@
     // test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
     // which creates writable files.
 #endif
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp
+++ test/libcxx/input.output/file.streams/fstreams/ifstream.members/open_wchar_pointer.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     {
@@ -44,4 +44,6 @@
         assert(c == L'r');
     }
 #endif
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
+++ test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
@@ -56,4 +56,6 @@
     }
     _wremove(temp.c_str());
 #endif
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp
+++ test/libcxx/input.output/file.streams/fstreams/ofstream.members/open_wchar_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
@@ -56,4 +56,6 @@
     }
     _wremove(temp.c_str());
 #endif
+
+  return 0;
 }
Index: test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp
+++ test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp
@@ -15,7 +15,7 @@
 
 #include <fstream>
 
-int main()
+int main(int, char**)
 {
 	std::basic_fstream<char, std::char_traits<wchar_t> > f;
 //  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
@@ -25,5 +25,7 @@
 // exception specifications for types which are already invalid for one reason or another.
 // For now we tolerate this diagnostic.
 // expected-error@ostream:* 0-1 {{exception specification of overriding function is more lax than base version}}
+
+  return 0;
 }
 
Index: test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
===================================================================
--- test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
+++ test/libcxx/input.output/file.streams/fstreams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp
===================================================================
--- test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp
+++ test/libcxx/input.output/filesystems/class.path/path.itr/iterator_db.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "filesystem_test_helper.hpp"
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   using ExType = std::__libcpp_debug_exception;
   // Test incrementing/decrementing a singular iterator
@@ -71,4 +71,6 @@
       assert(false);
     } catch (ExType const&) {}
   }
+
+  return 0;
 }
Index: test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
===================================================================
--- test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
+++ test/libcxx/input.output/filesystems/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
@@ -16,7 +16,7 @@
 #include <iterator>
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   using RIt = std::reverse_iterator<path::iterator>;
 
@@ -25,4 +25,6 @@
     RIt r;
     ((void)r);
   }
+
+  return 0;
 }
Index: test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
===================================================================
--- test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
+++ test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
@@ -95,9 +95,11 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   MakeTestType<char>::Test();
   MakeTestType<wchar_t>::Test();
   MakeTestType<char16_t>::Test();
   MakeTestType<char32_t>::Test();
+
+  return 0;
 }
Index: test/libcxx/input.output/filesystems/convert_file_time.sh.cpp
===================================================================
--- test/libcxx/input.output/filesystems/convert_file_time.sh.cpp
+++ test/libcxx/input.output/filesystems/convert_file_time.sh.cpp
@@ -277,7 +277,7 @@
 template <class IntType, class Period = std::micro>
 using TestFileTimeT = time_point<TestClock<duration<IntType, Period> > >;
 
-int main() {
+int main(int, char**) {
   { assert((test_case<file_time_type, time_t, struct timespec>::test())); }
   {
     assert((test_case<TestFileTimeT<int64_t>, int64_t,
@@ -303,4 +303,6 @@
                       TestTimeSpec<int32_t, int32_t> >::test()));
   }
 #endif
+
+  return 0;
 }
Index: test/libcxx/input.output/filesystems/version.pass.cpp
===================================================================
--- test/libcxx/input.output/filesystems/version.pass.cpp
+++ test/libcxx/input.output/filesystems/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp
===================================================================
--- test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp
+++ test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp
@@ -21,8 +21,10 @@
     : public std::basic_istream<char, std::char_traits<wchar_t> > {};
 
 
-int main()
+int main(int, char**)
 {
 //  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+
+  return 0;
 }
 
Index: test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
===================================================================
--- test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
+++ test/libcxx/input.output/iostream.format/input.streams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp
===================================================================
--- test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp
+++ test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.fail.cpp
@@ -21,8 +21,10 @@
     : public std::basic_ostream<char, std::char_traits<wchar_t> > {};
 
 
-int main()
+int main(int, char**)
 {
 //  expected-error-re@ios:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+
+  return 0;
 }
 
Index: test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
===================================================================
--- test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
+++ test/libcxx/input.output/iostream.format/output.streams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
===================================================================
--- test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
+++ test/libcxx/input.output/iostream.format/std.manip/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/iostream.forward/version.pass.cpp
===================================================================
--- test/libcxx/input.output/iostream.forward/version.pass.cpp
+++ test/libcxx/input.output/iostream.forward/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/iostream.objects/version.pass.cpp
===================================================================
--- test/libcxx/input.output/iostream.objects/version.pass.cpp
+++ test/libcxx/input.output/iostream.objects/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/iostreams.base/version.pass.cpp
===================================================================
--- test/libcxx/input.output/iostreams.base/version.pass.cpp
+++ test/libcxx/input.output/iostreams.base/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/stream.buffers/version.pass.cpp
===================================================================
--- test/libcxx/input.output/stream.buffers/version.pass.cpp
+++ test/libcxx/input.output/stream.buffers/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp
===================================================================
--- test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp
+++ test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp
@@ -16,10 +16,12 @@
 
 #include <sstream>
 
-int main()
+int main(int, char**)
 {
 	std::basic_stringbuf<char, std::char_traits<wchar_t> > sb;
 //  expected-error-re@streambuf:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
 //  expected-error-re@string:* {{static_assert failed{{.*}} "traits_type::char_type must be the same type as CharT"}}
+
+  return 0;
 }
 
Index: test/libcxx/input.output/string.streams/version.pass.cpp
===================================================================
--- test/libcxx/input.output/string.streams/version.pass.cpp
+++ test/libcxx/input.output/string.streams/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/iterators/failed.pass.cpp
===================================================================
--- test/libcxx/iterators/failed.pass.cpp
+++ test/libcxx/iterators/failed.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostreambuf_iterator<char> i(nullptr);
@@ -28,4 +28,6 @@
         std::ostreambuf_iterator<wchar_t> i(nullptr);
         assert(i.failed());
     }
+
+  return 0;
 }
Index: test/libcxx/iterators/trivial_iterators.pass.cpp
===================================================================
--- test/libcxx/iterators/trivial_iterators.pass.cpp
+++ test/libcxx/iterators/trivial_iterators.pass.cpp
@@ -90,7 +90,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
 //  basic tests
     static_assert(( std::__libcpp_is_trivial_iterator<char *>::value), "");
@@ -184,4 +184,6 @@
     static_assert(( std::__libcpp_is_trivial_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
 #endif
 
+
+  return 0;
 }
Index: test/libcxx/iterators/version.pass.cpp
===================================================================
--- test/libcxx/iterators/version.pass.cpp
+++ test/libcxx/iterators/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/cmp/version.pass.cpp
===================================================================
--- test/libcxx/language.support/cmp/version.pass.cpp
+++ test/libcxx/language.support/cmp/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/cstdint/version.pass.cpp
===================================================================
--- test/libcxx/language.support/cstdint/version.pass.cpp
+++ test/libcxx/language.support/cstdint/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
===================================================================
--- test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
+++ test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
@@ -21,7 +21,9 @@
 // XFAIL: with_system_cxx_lib=macosx10.7
 
 struct S { virtual void f() = delete; virtual ~S() {} };
-int main() {
+int main(int, char**) {
   S *s = new S;
   delete s;
+
+  return 0;
 }
Index: test/libcxx/language.support/has_c11_features.pass.cpp
===================================================================
--- test/libcxx/language.support/has_c11_features.pass.cpp
+++ test/libcxx/language.support/has_c11_features.pass.cpp
@@ -28,4 +28,6 @@
 # endif
 #endif
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
===================================================================
--- test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
+++ test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp
@@ -253,7 +253,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_libcpp_dealloc();
   test_allocator_and_new_match();
+
+  return 0;
 }
Index: test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
===================================================================
--- test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
+++ test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp
@@ -36,7 +36,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     static_assert(std::is_enum<std::align_val_t>::value, "");
     typedef std::underlying_type<std::align_val_t>::type UT;
@@ -88,4 +88,6 @@
     assert(typeid(std::align_val_t).name() == std::string("St11align_val_t"));
   }
 #endif
+
+  return 0;
 }
Index: test/libcxx/language.support/support.dynamic/version.pass.cpp
===================================================================
--- test/libcxx/language.support/support.dynamic/version.pass.cpp
+++ test/libcxx/language.support/support.dynamic/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.exception/version.pass.cpp
===================================================================
--- test/libcxx/language.support/support.exception/version.pass.cpp
+++ test/libcxx/language.support/support.exception/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.initlist/version.pass.cpp
===================================================================
--- test/libcxx/language.support/support.initlist/version.pass.cpp
+++ test/libcxx/language.support/support.initlist/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
===================================================================
--- test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
+++ test/libcxx/language.support/support.limits/c.limits/version_cfloat.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
===================================================================
--- test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
+++ test/libcxx/language.support/support.limits/c.limits/version_climits.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.limits/limits/version.pass.cpp
===================================================================
--- test/libcxx/language.support/support.limits/limits/version.pass.cpp
+++ test/libcxx/language.support/support.limits/limits/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.limits/version.pass.cpp
===================================================================
--- test/libcxx/language.support/support.limits/version.pass.cpp
+++ test/libcxx/language.support/support.limits/version.pass.cpp
@@ -14,6 +14,8 @@
 #error "_LIBCPP_VERSION must be defined after including <version>"
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.rtti/version.pass.cpp
===================================================================
--- test/libcxx/language.support/support.rtti/version.pass.cpp
+++ test/libcxx/language.support/support.rtti/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
===================================================================
--- test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
+++ test/libcxx/language.support/support.runtime/version_csetjmp.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
===================================================================
--- test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
+++ test/libcxx/language.support/support.runtime/version_csignal.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
===================================================================
--- test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
+++ test/libcxx/language.support/support.runtime/version_cstdarg.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
===================================================================
--- test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
+++ test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
===================================================================
--- test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
+++ test/libcxx/language.support/support.runtime/version_cstdlib.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
===================================================================
--- test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
+++ test/libcxx/language.support/support.runtime/version_ctime.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/language.support/support.types/version.pass.cpp
===================================================================
--- test/libcxx/language.support/support.types/version.pass.cpp
+++ test/libcxx/language.support/support.types/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/libcpp_alignof.pass.cpp
===================================================================
--- test/libcxx/libcpp_alignof.pass.cpp
+++ test/libcxx/libcpp_alignof.pass.cpp
@@ -28,9 +28,10 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test<int>();
   test<long long>();
   test<double>();
   test<long double>();
+  return 0;
 }
Index: test/libcxx/libcpp_version.pass.cpp
===================================================================
--- test/libcxx/libcpp_version.pass.cpp
+++ test/libcxx/libcpp_version.pass.cpp
@@ -22,6 +22,8 @@
 static_assert(_LIBCPP_VERSION == libcpp_version,
               "_LIBCPP_VERSION doesn't match __libcpp_version");
 
-int main() {
+int main(int, char**) {
 
+
+  return 0;
 }
Index: test/libcxx/localization/c.locales/version.pass.cpp
===================================================================
--- test/libcxx/localization/c.locales/version.pass.cpp
+++ test/libcxx/localization/c.locales/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
===================================================================
--- test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
+++ test/libcxx/localization/locale.categories/__scan_keyword.pass.cpp
@@ -38,7 +38,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::ctype<char>& ct = std::use_facet<std::ctype<char> >(std::locale::classic());
     std::ios_base::iostate err = std::ios_base::goodbit;
@@ -114,4 +114,6 @@
         assert(in == input+3);
         assert(err == std::ios_base::goodbit);
     }
+
+  return 0;
 }
Index: test/libcxx/localization/locale.stdcvt/version.pass.cpp
===================================================================
--- test/libcxx/localization/locale.stdcvt/version.pass.cpp
+++ test/libcxx/localization/locale.stdcvt/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
===================================================================
--- test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
+++ test/libcxx/localization/locales/locale.convenience/conversions/conversions.string/ctor_move.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;
@@ -34,4 +34,6 @@
     // move construct a new converter and make sure the state is the same.
     Myconv myconv2(std::move(myconv));
     assert(myconv2.converted() == old_converted);
+
+  return 0;
 }
Index: test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
===================================================================
--- test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
+++ test/libcxx/localization/locales/locale/locale.types/locale.facet/facet.pass.cpp
@@ -35,7 +35,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     my_facet* f = new my_facet;
     f->__add_shared();
@@ -49,4 +49,6 @@
     assert(my_facet::count == 1);
     f->__release_shared();
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
===================================================================
--- test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
+++ test/libcxx/localization/locales/locale/locale.types/locale.id/id.pass.cpp
@@ -25,7 +25,7 @@
 std::locale::id id2;
 std::locale::id id1;
 
-int main()
+int main(int, char**)
 {
     long id = id0.__get();
     assert(id0.__get() == id+0);
@@ -46,4 +46,6 @@
     assert(id2.__get() == id+2);
     assert(id2.__get() == id+2);
     assert(id2.__get() == id+2);
+
+  return 0;
 }
Index: test/libcxx/localization/version.pass.cpp
===================================================================
--- test/libcxx/localization/version.pass.cpp
+++ test/libcxx/localization/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/memory/aligned_allocation_macro.pass.cpp
===================================================================
--- test/libcxx/memory/aligned_allocation_macro.pass.cpp
+++ test/libcxx/memory/aligned_allocation_macro.pass.cpp
@@ -27,4 +27,6 @@
 #   error "libc++ should have aligned allocation in C++17 and up when targeting a platform that supports it"
 #endif
 
-int main() { }
+int main(int, char**) { 
+  return 0;
+}
Index: test/libcxx/memory/is_allocator.pass.cpp
===================================================================
--- test/libcxx/memory/is_allocator.pass.cpp
+++ test/libcxx/memory/is_allocator.pass.cpp
@@ -32,10 +32,12 @@
 }
 
 
-int main()
+int main(int, char**)
 {
 //	test_allocators<void>();
 	test_allocators<char>();
 	test_allocators<int>();
 	test_allocators<std::string>();
+
+  return 0;
 }
Index: test/libcxx/modules/cinttypes_exports.sh.cpp
===================================================================
--- test/libcxx/modules/cinttypes_exports.sh.cpp
+++ test/libcxx/modules/cinttypes_exports.sh.cpp
@@ -18,7 +18,9 @@
 
 #include <cinttypes>
 
-int main() {
+int main(int, char**) {
   int8_t x; ((void)x);
   std::int8_t y; ((void)y);
+
+  return 0;
 }
Index: test/libcxx/modules/clocale_exports.sh.cpp
===================================================================
--- test/libcxx/modules/clocale_exports.sh.cpp
+++ test/libcxx/modules/clocale_exports.sh.cpp
@@ -19,9 +19,11 @@
 
 #define TEST(...) do { using T = decltype( __VA_ARGS__ ); } while(false)
 
-int main() {
+int main(int, char**) {
   std::lconv l; ((void)l);
 
   TEST(std::setlocale(0, ""));
   TEST(std::localeconv());
+
+  return 0;
 }
Index: test/libcxx/modules/cstdint_exports.sh.cpp
===================================================================
--- test/libcxx/modules/cstdint_exports.sh.cpp
+++ test/libcxx/modules/cstdint_exports.sh.cpp
@@ -18,7 +18,9 @@
 
 #include <cstdint>
 
-int main() {
+int main(int, char**) {
   int8_t x; ((void)x);
   std::int8_t y; ((void)y);
+
+  return 0;
 }
Index: test/libcxx/modules/inttypes_h_exports.sh.cpp
===================================================================
--- test/libcxx/modules/inttypes_h_exports.sh.cpp
+++ test/libcxx/modules/inttypes_h_exports.sh.cpp
@@ -18,6 +18,8 @@
 
 #include <inttypes.h>
 
-int main() {
+int main(int, char**) {
   int8_t x; ((void)x);
+
+  return 0;
 }
Index: test/libcxx/modules/stdint_h_exports.sh.cpp
===================================================================
--- test/libcxx/modules/stdint_h_exports.sh.cpp
+++ test/libcxx/modules/stdint_h_exports.sh.cpp
@@ -14,6 +14,8 @@
 
 #include <stdint.h>
 
-int main() {
+int main(int, char**) {
   int8_t x; ((void)x);
+
+  return 0;
 }
Index: test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
===================================================================
--- test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
+++ test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
@@ -26,6 +26,8 @@
 static_assert(std::__libcpp_isinf_or_builtin(0.0) == false, "");
 static_assert(std::__libcpp_isfinite_or_builtin(0.0) == true, "");
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/numerics/c.math/ctgmath.pass.cpp
===================================================================
--- test/libcxx/numerics/c.math/ctgmath.pass.cpp
+++ test/libcxx/numerics/c.math/ctgmath.pass.cpp
@@ -14,10 +14,12 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::complex<double> cd;
     ((void)cd);
     double x = std::sin(0);
     ((void)x);
+
+  return 0;
 }
Index: test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
===================================================================
--- test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
+++ test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
@@ -18,10 +18,12 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   assert(std::isfinite(1.0));
   assert(!std::isinf(1.0));
   assert(!std::isnan(1.0));
+
+  return 0;
 }
 
 using namespace std;
Index: test/libcxx/numerics/c.math/tgmath_h.pass.cpp
===================================================================
--- test/libcxx/numerics/c.math/tgmath_h.pass.cpp
+++ test/libcxx/numerics/c.math/tgmath_h.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/numerics/c.math/version_cmath.pass.cpp
===================================================================
--- test/libcxx/numerics/c.math/version_cmath.pass.cpp
+++ test/libcxx/numerics/c.math/version_cmath.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/numerics/cfenv/version.pass.cpp
===================================================================
--- test/libcxx/numerics/cfenv/version.pass.cpp
+++ test/libcxx/numerics/cfenv/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/numerics/complex.number/__sqr.pass.cpp
===================================================================
--- test/libcxx/numerics/complex.number/__sqr.pass.cpp
+++ test/libcxx/numerics/complex.number/__sqr.pass.cpp
@@ -72,9 +72,11 @@
     assert(inf2.real() < 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
===================================================================
--- test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -14,8 +14,10 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::complex<double> d;
     (void)d;
+
+  return 0;
 }
Index: test/libcxx/numerics/complex.number/version.pass.cpp
===================================================================
--- test/libcxx/numerics/complex.number/version.pass.cpp
+++ test/libcxx/numerics/complex.number/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/numerics/numarray/version.pass.cpp
===================================================================
--- test/libcxx/numerics/numarray/version.pass.cpp
+++ test/libcxx/numerics/numarray/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/numerics/numeric.ops/version.pass.cpp
===================================================================
--- test/libcxx/numerics/numeric.ops/version.pass.cpp
+++ test/libcxx/numerics/numeric.ops/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
===================================================================
--- test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
+++ test/libcxx/numerics/rand/rand.synopsis/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/selftest/not_test.sh.cpp
===================================================================
--- test/libcxx/selftest/not_test.sh.cpp
+++ test/libcxx/selftest/not_test.sh.cpp
@@ -10,7 +10,7 @@
 // RUN: %build
 // RUN: not %run
 
-int main()
+int main(int, char**)
 {
   return 1;
 }
Index: test/libcxx/selftest/test.arc.pass.mm
===================================================================
--- test/libcxx/selftest/test.arc.pass.mm
+++ test/libcxx/selftest/test.arc.pass.mm
@@ -11,6 +11,4 @@
 #error "arc should be enabled"
 #endif
 
-int main()
-{
-}
+int main(int, char**) { return 0; }
Index: test/libcxx/selftest/test.pass.cpp
===================================================================
--- test/libcxx/selftest/test.pass.cpp
+++ test/libcxx/selftest/test.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/selftest/test.pass.mm
===================================================================
--- test/libcxx/selftest/test.pass.mm
+++ test/libcxx/selftest/test.pass.mm
@@ -11,6 +11,4 @@
 #error "arc should *not* be enabled"
 #endif
 
-int main()
-{
-}
+int main(int, char**) { return 0; }
Index: test/libcxx/selftest/test.sh.cpp
===================================================================
--- test/libcxx/selftest/test.sh.cpp
+++ test/libcxx/selftest/test.sh.cpp
@@ -10,6 +10,8 @@
 // RUN: %build
 // RUN: %run
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/selftest/test_macros.pass.cpp
===================================================================
--- test/libcxx/selftest/test_macros.pass.cpp
+++ test/libcxx/selftest/test_macros.pass.cpp
@@ -58,8 +58,10 @@
 //  ===== C++17 features =====
 }
 
-int main()
+int main(int, char**)
 {
     test_noexcept();
     test_libcxx_macros();
+
+  return 0;
 }
Index: test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string l = "Long string so that allocation definitely, for sure, absolutely happens. Probably.";
     std::string s = "short";
@@ -40,8 +40,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -43,8 +43,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -45,8 +45,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -43,8 +43,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -43,8 +43,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -43,8 +43,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string l1("123");
@@ -41,8 +41,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -28,4 +28,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -30,4 +30,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -27,4 +27,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
===================================================================
--- test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
+++ test/libcxx/strings/basic.string/string.modifiers/resize_default_initialized.pass.cpp
@@ -56,7 +56,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_buffer_usage();
+
+  return 0;
 }
Index: test/libcxx/strings/c.strings/version_cctype.pass.cpp
===================================================================
--- test/libcxx/strings/c.strings/version_cctype.pass.cpp
+++ test/libcxx/strings/c.strings/version_cctype.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/strings/c.strings/version_cstring.pass.cpp
===================================================================
--- test/libcxx/strings/c.strings/version_cstring.pass.cpp
+++ test/libcxx/strings/c.strings/version_cstring.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/strings/c.strings/version_cuchar.pass.cpp
===================================================================
--- test/libcxx/strings/c.strings/version_cuchar.pass.cpp
+++ test/libcxx/strings/c.strings/version_cuchar.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/strings/c.strings/version_cwchar.pass.cpp
===================================================================
--- test/libcxx/strings/c.strings/version_cwchar.pass.cpp
+++ test/libcxx/strings/c.strings/version_cwchar.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/strings/c.strings/version_cwctype.pass.cpp
===================================================================
--- test/libcxx/strings/c.strings/version_cwctype.pass.cpp
+++ test/libcxx/strings/c.strings/version_cwctype.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/strings/iterators.exceptions.pass.cpp
===================================================================
--- test/libcxx/strings/iterators.exceptions.pass.cpp
+++ test/libcxx/strings/iterators.exceptions.pass.cpp
@@ -33,7 +33,7 @@
 static const bool expected = true;
 #endif
 
-int main()
+int main(int, char**)
 {
 //  basic tests
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<char *>::value), "");
@@ -84,4 +84,6 @@
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::iterator>              ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
 #endif
+
+  return 0;
 }
Index: test/libcxx/strings/iterators.noexcept.pass.cpp
===================================================================
--- test/libcxx/strings/iterators.noexcept.pass.cpp
+++ test/libcxx/strings/iterators.noexcept.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
 //  basic tests
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<char *>::value), "");
@@ -77,4 +77,6 @@
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::iterator>              ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
 #endif
+
+  return 0;
 }
Index: test/libcxx/strings/version.pass.cpp
===================================================================
--- test/libcxx/strings/version.pass.cpp
+++ test/libcxx/strings/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
===================================================================
--- test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
+++ test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp
@@ -31,7 +31,7 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
     typedef std::__libcpp_debug_exception ExType;
     {
@@ -52,4 +52,6 @@
         } catch (ExType const&) {
         }
     }
+
+  return 0;
 }
Index: test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
===================================================================
--- test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
+++ test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
@@ -31,7 +31,7 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
     typedef std::__libcpp_debug_exception ExType;
     {
@@ -52,4 +52,6 @@
         } catch (ExType const& value) {
         }
     }
+
+  return 0;
 }
Index: test/libcxx/thread/futures/futures.task/types.pass.cpp
===================================================================
--- test/libcxx/thread/futures/futures.task/types.pass.cpp
+++ test/libcxx/thread/futures/futures.task/types.pass.cpp
@@ -24,7 +24,9 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::packaged_task<A(int, char)>::result_type, A>::value), "");
+
+  return 0;
 }
Index: test/libcxx/thread/futures/version.pass.cpp
===================================================================
--- test/libcxx/thread/futures/version.pass.cpp
+++ test/libcxx/thread/futures/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
===================================================================
--- test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
+++ test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
@@ -45,7 +45,7 @@
     return nullptr;
 }
 
-int main()
+int main(int, char**)
 {
     {
     std::unique_lock<std::mutex> lk(mut);
@@ -72,4 +72,6 @@
     assert(t1-t0 > ms(250));
     t.join();
     }
+
+  return 0;
 }
Index: test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
===================================================================
--- test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
+++ test/libcxx/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp
@@ -20,11 +20,13 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::condition_variable::native_handle_type,
                                 pthread_cond_t*>::value), "");
     std::condition_variable cv;
     std::condition_variable::native_handle_type h = cv.native_handle();
     assert(h != nullptr);
+
+  return 0;
 }
Index: test/libcxx/thread/thread.condition/version.pass.cpp
===================================================================
--- test/libcxx/thread/thread.condition/version.pass.cpp
+++ test/libcxx/thread/thread.condition/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
===================================================================
--- test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
+++ test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp
@@ -20,9 +20,11 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::mutex m;
     pthread_mutex_t* h = m.native_handle();
     assert(h);
+
+  return 0;
 }
Index: test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
===================================================================
--- test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
+++ test/libcxx/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp
@@ -20,9 +20,11 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::recursive_mutex m;
     pthread_mutex_t* h = m.native_handle();
     assert(h);
+
+  return 0;
 }
Index: test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
===================================================================
--- test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
+++ test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp
@@ -16,10 +16,12 @@
 
 #include <mutex>
 
-int main() {
+int main(int, char**) {
   std::mutex m;
   m.lock();
   {
     std::unique_lock<std::mutex> g(m, std::adopt_lock);
   }
+
+  return 0;
 }
Index: test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
===================================================================
--- test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
+++ test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
@@ -32,8 +32,10 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   scoped();
   std::lock_guard<std::mutex> lock(m);
   foo++;
+
+  return 0;
 }
Index: test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
===================================================================
--- test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
+++ test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
@@ -23,8 +23,10 @@
 std::mutex m;
 int foo __attribute__((guarded_by(m)));
 
-int main() {
+int main(int, char**) {
   m.lock();
   foo++;
   m.unlock();
+
+  return 0;
 }
Index: test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
===================================================================
--- test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
+++ test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.fail.cpp
@@ -22,6 +22,8 @@
 
 std::mutex m;
 
-int main() {
+int main(int, char**) {
   m.lock();
+
+  return 0;
 } // expected-error {{mutex 'm' is still held at the end of function}}
Index: test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
===================================================================
--- test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
+++ test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
@@ -27,8 +27,10 @@
   foo++;
 }
 
-int main() {
+int main(int, char**) {
   m.lock();
   increment();
   m.unlock();
+
+  return 0;
 }
Index: test/libcxx/thread/thread.mutex/version.pass.cpp
===================================================================
--- test/libcxx/thread/thread.mutex/version.pass.cpp
+++ test/libcxx/thread/thread.mutex/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
===================================================================
--- test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
+++ test/libcxx/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp
@@ -43,7 +43,7 @@
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -52,4 +52,6 @@
         assert(pid != 0);
         t0.join();
     }
+
+  return 0;
 }
Index: test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
===================================================================
--- test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
+++ test/libcxx/thread/thread.threads/thread.thread.class/types.pass.cpp
@@ -21,7 +21,9 @@
 #include <thread>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::thread::native_handle_type, pthread_t>::value), "");
+
+  return 0;
 }
Index: test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp
===================================================================
--- test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp
+++ test/libcxx/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp
@@ -34,7 +34,7 @@
 
 void sig_action(int) {}
 
-int main()
+int main(int, char**)
 {
     int ec;
     struct sigaction action;
@@ -64,4 +64,6 @@
     std::chrono::nanoseconds err = 5 * ms / 100;
     // The time slept is within 5% of 500ms
     assert(std::abs(ns.count()) < err.count());
+
+  return 0;
 }
Index: test/libcxx/thread/thread.threads/version.pass.cpp
===================================================================
--- test/libcxx/thread/thread.threads/version.pass.cpp
+++ test/libcxx/thread/thread.threads/version.pass.cpp
@@ -16,6 +16,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/type_traits/convert_to_integral.pass.cpp
===================================================================
--- test/libcxx/type_traits/convert_to_integral.pass.cpp
+++ test/libcxx/type_traits/convert_to_integral.pass.cpp
@@ -79,7 +79,7 @@
   value = std::numeric_limits<unsigned long>::max()
 };
 
-int main()
+int main(int, char**)
 {
   check_integral_types<bool, int>();
   check_integral_types<char, int>();
@@ -105,4 +105,6 @@
   check_enum_types<enum1, decltype(((Enum1UT)1) + 1)>();
   typedef std::underlying_type<enum2>::type Enum2UT;
   check_enum_types<enum2, decltype(((Enum2UT)1) + 1)>();
+
+  return 0;
 }
Index: test/libcxx/type_traits/lazy_metafunctions.pass.cpp
===================================================================
--- test/libcxx/type_traits/lazy_metafunctions.pass.cpp
+++ test/libcxx/type_traits/lazy_metafunctions.pass.cpp
@@ -128,9 +128,11 @@
 }
 
 
-int main() {
+int main(int, char**) {
     LazyEnableIfTest();
     LazyNotTest();
     LazyAndTest();
     LazyOrTest();
+
+  return 0;
 }
Index: test/libcxx/utilities/any/size_and_alignment.pass.cpp
===================================================================
--- test/libcxx/utilities/any/size_and_alignment.pass.cpp
+++ test/libcxx/utilities/any/size_and_alignment.pass.cpp
@@ -14,9 +14,11 @@
 
 #include <any>
 
-int main()
+int main(int, char**)
 {
     using std::any;
     static_assert(sizeof(any) == sizeof(void*)*4, "");
     static_assert(alignof(any) == alignof(void*), "");
+
+  return 0;
 }
Index: test/libcxx/utilities/any/small_type.pass.cpp
===================================================================
--- test/libcxx/utilities/any/small_type.pass.cpp
+++ test/libcxx/utilities/any/small_type.pass.cpp
@@ -54,7 +54,7 @@
     char buff[BufferSize + 1];
 };
 
-int main()
+int main(int, char**)
 {
     using std::any;
     using std::__any_imp::_IsSmallObject;
@@ -110,4 +110,6 @@
         static_assert(alignof(T) > BufferAlignment, "");
         static_assert(!_IsSmallObject<T>::value, "");
     }
+
+  return 0;
 }
Index: test/libcxx/utilities/any/version.pass.cpp
===================================================================
--- test/libcxx/utilities/any/version.pass.cpp
+++ test/libcxx/utilities/any/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
===================================================================
--- test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
+++ test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
@@ -271,7 +271,7 @@
 }
 #endif
 
-int main() {
+int main(int, char**) {
     typedef void*& R;
     typedef ArgType A;
     TestCase<R(),                                   0, Q_None>::run();
@@ -367,4 +367,6 @@
 
     test_derived_from_ref_wrap();
 #endif
+
+  return 0;
 }
Index: test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
===================================================================
--- test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
+++ test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
@@ -206,10 +206,12 @@
 
 
 
-int main() {
+int main(int, char**) {
     TestCase<ArgType>::run();
     TestCase<ArgType const>::run();
     TestCase<ArgType volatile>::run();
     TestCase<ArgType const volatile>::run();
     TestCase<ArgType*>::run();
+
+  return 0;
 }
Index: test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
===================================================================
--- test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
+++ test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
@@ -247,7 +247,7 @@
     runFunctorTestCase <Sig, Arity, LValueCaster, ArgCaster>();
 };
 
-int main() {
+int main(int, char**) {
     typedef void*& R;
     typedef ArgType A;
     typedef A const CA;
@@ -323,4 +323,6 @@
     runFunctorTestCase11<R(A&&) const volatile &&, 1, MoveCVCaster,       MC>();
     }
 #endif
+
+  return 0;
 }
Index: test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
===================================================================
--- test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
+++ test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
@@ -31,7 +31,7 @@
 #endif
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(sizeof(std::__invoke(&Type::f1, std::declval<Type        >())) == 1, "");
     static_assert(sizeof(std::__invoke(&Type::f2, std::declval<Type const  >())) == 2, "");
@@ -41,4 +41,6 @@
     static_assert(sizeof(std::__invoke(&Type::g3, std::declval<Type      &&>())) == 3, "");
     static_assert(sizeof(std::__invoke(&Type::g4, std::declval<Type const&&>())) == 4, "");
 #endif
+
+  return 0;
 }
Index: test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
===================================================================
--- test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
+++ test/libcxx/utilities/function.objects/refwrap/binary.pass.cpp
@@ -46,7 +46,7 @@
     typedef int result_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((!std::is_base_of<std::binary_function<int, char, int>,
                                     std::reference_wrapper<functor1> >::value), "");
@@ -76,4 +76,6 @@
                                    std::reference_wrapper<float(C::*)(int)> >::value), "");
     static_assert((std::is_base_of<std::binary_function<const volatile C*, int, float>,
                                    std::reference_wrapper<float(C::*)(int) const volatile> >::value), "");
+
+  return 0;
 }
Index: test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
===================================================================
--- test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
+++ test/libcxx/utilities/function.objects/refwrap/unary.pass.cpp
@@ -46,7 +46,7 @@
     typedef int result_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::unary_function<int, char>,
                                    std::reference_wrapper<functor1> >::value), "");
@@ -74,4 +74,6 @@
                                    std::reference_wrapper<float(C::*)() const volatile> >::value), "");
     static_assert((!std::is_base_of<std::unary_function<C*, float>,
                                    std::reference_wrapper<float(C::*)(int)> >::value), "");
+
+  return 0;
 }
Index: test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
===================================================================
--- test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
+++ test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
@@ -28,7 +28,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   const std::string TestCases[] = {
       "abcdaoeuaoeclaoeoaeuaoeuaousaotehu]+}sthoasuthaoesutahoesutaohesutaoeusaoetuhasoetuhaoseutaoseuthaoesutaohes"
       "00000000000000000000000000000000000000000000000000000000000000000000000",
@@ -37,4 +37,6 @@
   const size_t NumCases = sizeof(TestCases)/sizeof(TestCases[0]);
   for (size_t i=0; i < NumCases; ++i)
     test(TestCases[i].data(), TestCases[i].length());
+
+  return 0;
 }
Index: test/libcxx/utilities/function.objects/version.pass.cpp
===================================================================
--- test/libcxx/utilities/function.objects/version.pass.cpp
+++ test/libcxx/utilities/function.objects/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
===================================================================
--- test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
+++ test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_cxx03.pass.cpp
@@ -28,7 +28,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_IS_UNSUPPORTED
   {
@@ -42,4 +42,6 @@
     test_pr26961();
   }
 #endif
+
+  return 0;
 }
Index: test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp
===================================================================
--- test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp
+++ test/libcxx/utilities/memory/util.dynamic.safety/get_pointer_safety_new_abi.pass.cpp
@@ -18,7 +18,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
   {
     static_assert(std::is_enum<std::pointer_safety>::value, "");
@@ -34,4 +34,6 @@
            r == std::pointer_safety::preferred ||
            r == std::pointer_safety::strict);
   }
+
+  return 0;
 }
Index: test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp
===================================================================
--- test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp
+++ test/libcxx/utilities/memory/util.smartptr/race_condition.pass.cpp
@@ -77,7 +77,7 @@
     assert(p.use_count() == 3);
 }
 
-int main() {
+int main(int, char**) {
   {
     // Test with out-of-place shared_count.
     Ptr p(new int(42));
@@ -91,4 +91,6 @@
     run_test(p);
     assert(p.use_count() == 1);
   }
+
+  return 0;
 }
Index: test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
===================================================================
--- test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
+++ test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
@@ -29,7 +29,7 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   {
     SPtr<0> s; // OK
     SPtr<1> s1(nullptr); // OK
@@ -41,4 +41,6 @@
     SPtr<4> s4(getFn<4>()); // expected-note {{requested here}}
     SPtr<5> s5(getFn<5>(), std::default_delete<FnType<5>>{}); // expected-note {{requested here}}
   }
+
+  return 0;
 }
Index: test/libcxx/utilities/memory/version.pass.cpp
===================================================================
--- test/libcxx/utilities/memory/version.pass.cpp
+++ test/libcxx/utilities/memory/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/meta/is_referenceable.pass.cpp
===================================================================
--- test/libcxx/utilities/meta/is_referenceable.pass.cpp
+++ test/libcxx/utilities/meta/is_referenceable.pass.cpp
@@ -189,4 +189,6 @@
 static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) const &&>::value), "");
 #endif
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
Index: test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
===================================================================
--- test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
+++ test/libcxx/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp
@@ -55,7 +55,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     static_assert(std::__has_operator_addressof<int>::value == false, "");
     static_assert(std::__has_operator_addressof<A>::value == false, "");
@@ -65,4 +65,6 @@
     static_assert(std::__has_operator_addressof<G>::value == true, "");
     static_assert(std::__has_operator_addressof<H>::value == true, "");
     static_assert(std::__has_operator_addressof<J>::value == true, "");
+
+  return 0;
 }
Index: test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp
===================================================================
--- test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp
+++ test/libcxx/utilities/meta/meta.unary/meta.unary.prop/missing_is_aggregate_trait.fail.cpp
@@ -15,7 +15,7 @@
 
 #include <type_traits>
 
-int main ()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_NO_IS_AGGREGATE
   // This should not compile when _LIBCPP_HAS_NO_IS_AGGREGATE is defined.
@@ -24,4 +24,6 @@
 #else
 #error Forcing failure...
 #endif
+
+  return 0;
 }
Index: test/libcxx/utilities/meta/version.pass.cpp
===================================================================
--- test/libcxx/utilities/meta/version.pass.cpp
+++ test/libcxx/utilities/meta/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
===================================================================
--- test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
+++ test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
@@ -53,7 +53,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     {
         using T = int;
@@ -70,4 +70,6 @@
 
     static_assert(!(std::is_copy_assignable<optional<Z1>>::value), "");
     static_assert(!(std::is_copy_assignable<optional<Z2>>::value), "");
+
+  return 0;
 }
Index: test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
===================================================================
--- test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
+++ test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -50,7 +50,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     {
         using T = int;
@@ -67,4 +67,6 @@
 
     static_assert(!(std::is_move_assignable<optional<Z1>>::value), "");
     static_assert(!(std::is_move_assignable<optional<Z2>>::value), "");
+
+  return 0;
 }
Index: test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
===================================================================
--- test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -35,7 +35,7 @@
     Z& operator=(const Z&) = delete;
 };
 
-int main()
+int main(int, char**)
 {
     {
         using T = int;
@@ -55,4 +55,6 @@
     static_assert(!(std::is_trivially_copy_constructible<optional<std::string>>::value), "");
 
     static_assert(!(std::is_copy_constructible<optional<Z>>::value), "");
+
+  return 0;
 }
Index: test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
===================================================================
--- test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -36,7 +36,7 @@
     Z& operator=(const Z&) = delete;
 };
 
-int main()
+int main(int, char**)
 {
     {
         using T = int;
@@ -56,4 +56,6 @@
     static_assert(!(std::is_trivially_move_constructible<optional<std::string>>::value), "");
 
     static_assert(!(std::is_move_constructible<optional<Z>>::value), "");
+
+  return 0;
 }
Index: test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
===================================================================
--- test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
+++ test/libcxx/utilities/optional/optional.object/triviality.abi.pass.cpp
@@ -85,7 +85,7 @@
     TrivialCopyNonTrivialMove& operator=(TrivialCopyNonTrivialMove&&) { return *this; }
 };
 
-int main()
+int main(int, char**)
 {
     sink(
         ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
@@ -94,4 +94,6 @@
         NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{},
         DoTestsMetafunction<TrivialMoveNonTrivialCopy, TrivialCopyNonTrivialMove>{}
     );
+
+  return 0;
 }
Index: test/libcxx/utilities/optional/version.pass.cpp
===================================================================
--- test/libcxx/utilities/optional/version.pass.cpp
+++ test/libcxx/utilities/optional/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/ratio/version.pass.cpp
===================================================================
--- test/libcxx/utilities/ratio/version.pass.cpp
+++ test/libcxx/utilities/ratio/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/template.bitset/includes.pass.cpp
===================================================================
--- test/libcxx/utilities/template.bitset/includes.pass.cpp
+++ test/libcxx/utilities/template.bitset/includes.pass.cpp
@@ -26,6 +26,8 @@
 #error <iosfwd> has not been included
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/template.bitset/version.pass.cpp
===================================================================
--- test/libcxx/utilities/template.bitset/version.pass.cpp
+++ test/libcxx/utilities/template.bitset/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp
===================================================================
--- test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp
+++ test/libcxx/utilities/time/date.time/asctime.thread-unsafe.fail.cpp
@@ -10,8 +10,10 @@
 
 #include <ctime>
 
-int main() {
+int main(int, char**) {
     // asctime is not thread-safe.
     std::time_t t = 0;
     std::asctime(&t);
+
+  return 0;
 }
Index: test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp
===================================================================
--- test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp
+++ test/libcxx/utilities/time/date.time/ctime.thread-unsafe.fail.cpp
@@ -10,8 +10,10 @@
 
 #include <ctime>
 
-int main() {
+int main(int, char**) {
     // ctime is not thread-safe.
     std::time_t t = 0;
     std::ctime(&t);
+
+  return 0;
 }
Index: test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp
===================================================================
--- test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp
+++ test/libcxx/utilities/time/date.time/gmtime.thread-unsafe.fail.cpp
@@ -10,8 +10,10 @@
 
 #include <ctime>
 
-int main() {
+int main(int, char**) {
     // gmtime is not thread-safe.
     std::time_t t = 0;
     std::gmtime(&t);
+
+  return 0;
 }
Index: test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp
===================================================================
--- test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp
+++ test/libcxx/utilities/time/date.time/localtime.thread-unsafe.fail.cpp
@@ -10,8 +10,10 @@
 
 #include <ctime>
 
-int main() {
+int main(int, char**) {
     // localtime is not thread-safe.
     std::time_t t = 0;
     std::localtime(&t);
+
+  return 0;
 }
Index: test/libcxx/utilities/time/version.pass.cpp
===================================================================
--- test/libcxx/utilities/time/version.pass.cpp
+++ test/libcxx/utilities/time/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp
===================================================================
--- test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp
+++ test/libcxx/utilities/tuple/tuple.tuple/empty_member.pass.cpp
@@ -20,7 +20,7 @@
 
 struct B {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<int, A> T;
@@ -42,4 +42,6 @@
         typedef std::tuple<int, A, B> T;
         static_assert((sizeof(T) == sizeof(int)), "");
     }
+
+  return 0;
 }
Index: test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
===================================================================
--- test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
+++ test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp
@@ -43,7 +43,7 @@
 void F(typename CannotDeduce<std::tuple<Args...>>::type const&) {}
 
 
-int main() {
+int main(int, char**) {
 #if TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary)
   // Test that we emit our diagnostic from the library.
   // expected-error@tuple:* 8 {{"Attempted construction of reference element binds to a temporary whose lifetime has ended"}}
@@ -81,4 +81,6 @@
 #error force failure
 // expected-error@-1 {{force failure}}
 #endif
+
+  return 0;
 }
Index: test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp
===================================================================
--- test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp
+++ test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp
@@ -77,7 +77,7 @@
   assert(std::get<2>(tup) == std::error_code{});
 }
 
-int main()
+int main(int, char**)
 {
     {
         using E = MoveOnly;
@@ -104,4 +104,6 @@
     // constructor extensions.
     test_default_constructible_extension_sfinae();
     test_example_from_docs();
+
+  return 0;
 }
Index: test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp
===================================================================
--- test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp
+++ test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp
@@ -89,7 +89,7 @@
   assert(std::get<2>(tup) == std::error_code{});
 }
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -113,4 +113,6 @@
     // constructor extensions.
     test_default_constructible_extension_sfinae();
     test_example_from_docs();
+
+  return 0;
 }
Index: test/libcxx/utilities/tuple/version.pass.cpp
===================================================================
--- test/libcxx/utilities/tuple/version.pass.cpp
+++ test/libcxx/utilities/tuple/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/type.index/version.pass.cpp
===================================================================
--- test/libcxx/utilities/type.index/version.pass.cpp
+++ test/libcxx/utilities/type.index/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/__is_inplace_index.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/__is_inplace_index.pass.cpp
+++ test/libcxx/utilities/utility/__is_inplace_index.pass.cpp
@@ -14,7 +14,7 @@
 
 struct S {};
 
-int main() {
+int main(int, char**) {
   using I = std::in_place_index_t<0>;
   static_assert( std::__is_inplace_index<I>::value, "");
   static_assert( std::__is_inplace_index<const I>::value, "");
@@ -30,4 +30,6 @@
   static_assert(!std::__is_inplace_index<void>::value, "");
   static_assert(!std::__is_inplace_index<int>::value, "");
   static_assert(!std::__is_inplace_index<S>::value, "");
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/__is_inplace_type.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/__is_inplace_type.pass.cpp
+++ test/libcxx/utilities/utility/__is_inplace_type.pass.cpp
@@ -14,7 +14,7 @@
 
 struct S {};
 
-int main() {
+int main(int, char**) {
   using T = std::in_place_type_t<int>;
   static_assert( std::__is_inplace_type<T>::value, "");
   static_assert( std::__is_inplace_type<const T>::value, "");
@@ -30,4 +30,6 @@
   static_assert(!std::__is_inplace_type<void>::value, "");
   static_assert(!std::__is_inplace_type<int>::value, "");
   static_assert(!std::__is_inplace_type<S>::value, "");
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
@@ -37,7 +37,7 @@
     int value;
 };
 
-int main() {
+int main(int, char**) {
     { // explicit noexcept test
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitT, ExplicitT>, int, int>::value, "");
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitNothrowT, ExplicitT>, int, int>::value, "");
@@ -50,4 +50,6 @@
         static_assert(!std::is_nothrow_constructible<std::pair<ImplicitT, ImplicitNothrowT>, int, int>::value, "");
         static_assert( std::is_nothrow_constructible<std::pair<ImplicitNothrowT, ImplicitNothrowT>, int, int>::value, "");
     }
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/assign_tuple_like.pass.cpp
@@ -27,7 +27,7 @@
 #pragma clang diagnostic ignored "-Wmissing-braces"
 #endif
 
-int main()
+int main(int, char**)
 {
     using C = TestTypes::TestType;
     {
@@ -100,4 +100,6 @@
        assert(p.first.value == 42);
        assert(p.second.value == -42);
     }
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
@@ -37,7 +37,7 @@
     ImplicitNothrowT(ImplicitNothrowT const&) noexcept {}
 };
 
-int main() {
+int main(int, char**) {
     { // explicit noexcept test
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitT, ExplicitT>,
                                                      ExplicitT const&, ExplicitT const&>::value, "");
@@ -58,4 +58,6 @@
         static_assert( std::is_nothrow_constructible<std::pair<ImplicitNothrowT, ImplicitNothrowT>,
                                                      ImplicitNothrowT const&, ImplicitNothrowT const&>::value, "");
     }
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
@@ -39,7 +39,7 @@
     int value;
 };
 
-int main() {
+int main(int, char**) {
     { // explicit noexcept test
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitT, ExplicitT>,
                                                      std::pair<int, int> const&>::value, "");
@@ -60,4 +60,6 @@
         static_assert( std::is_nothrow_constructible<std::pair<ImplicitNothrowT, ImplicitNothrowT>,
                                                      std::pair<int, int> const&>::value, "");
     }
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/default.pass.cpp
@@ -26,10 +26,12 @@
   NonThrowingDefault() noexcept { }
 };
 
-int main() {
+int main(int, char**) {
 
     static_assert(!std::is_nothrow_default_constructible<std::pair<ThrowingDefault, ThrowingDefault>>::value, "");
     static_assert(!std::is_nothrow_default_constructible<std::pair<NonThrowingDefault, ThrowingDefault>>::value, "");
     static_assert(!std::is_nothrow_default_constructible<std::pair<ThrowingDefault, NonThrowingDefault>>::value, "");
     static_assert( std::is_nothrow_default_constructible<std::pair<NonThrowingDefault, NonThrowingDefault>>::value, "");
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/non_trivial_copy_move_ABI.pass.cpp
@@ -158,7 +158,8 @@
     static_assert(offsetof(PairT, first) == 0, "");
 }
 
-int main() {
+int main(int, char**) {
     test_trivial();
     test_layout();
+    return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.fail.cpp
@@ -14,11 +14,13 @@
 
 #include <utility>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, double> P;
     std::tuple_element<2, P>::type foo; // expected-note {{requested here}}
         // expected-error-re@utility:* {{static_assert failed{{( due to requirement '2U[L]{0,2} < 2')?}} "Index out of bounds in std::tuple_element<std::pair<T1, T2>>"}}
     }
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
@@ -23,7 +23,7 @@
 #include "archetypes.hpp"
 
 
-int main() {
+int main(int, char**) {
     using NonThrowingConvert = NonThrowingTypes::ConvertingType;
     using ThrowingConvert = NonTrivialTypes::ConvertingType;
     static_assert(!std::is_nothrow_constructible<std::pair<ThrowingConvert, ThrowingConvert>,
@@ -34,4 +34,6 @@
                                                  std::piecewise_construct_t, std::tuple<int, int>, std::tuple<long, long>>::value, "");
     static_assert( std::is_nothrow_constructible<std::pair<NonThrowingConvert, NonThrowingConvert>,
                                                  std::piecewise_construct_t, std::tuple<int, int>, std::tuple<long, long>>::value, "");
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
@@ -38,7 +38,7 @@
     int value;
 };
 
-int main() {
+int main(int, char**) {
     { // explicit noexcept test
         static_assert(!std::is_nothrow_constructible<std::pair<ExplicitT, ExplicitT>,
                                                      std::pair<int, int>&&>::value, "");
@@ -59,4 +59,6 @@
         static_assert( std::is_nothrow_constructible<std::pair<ImplicitNothrowT, ImplicitNothrowT>,
                                                      std::pair<int, int>&&>::value, "");
     }
+
+  return 0;
 }
Index: test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
+++ test/libcxx/utilities/utility/pairs/pairs.pair/trivial_copy_move_ABI.pass.cpp
@@ -153,7 +153,8 @@
     static_assert(offsetof(PairT, first) == 0, "");
 }
 
-int main() {
+int main(int, char**) {
     test_trivial();
     test_layout();
+    return 0;
 }
Index: test/libcxx/utilities/utility/version.pass.cpp
===================================================================
--- test/libcxx/utilities/utility/version.pass.cpp
+++ test/libcxx/utilities/utility/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp
===================================================================
--- test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp
+++ test/libcxx/utilities/variant/variant.variant/variant.helper/variant_alternative.fail.cpp
@@ -25,11 +25,13 @@
 #include <cassert>
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::variant<int, double> T;
         std::variant_alternative<2, T>::type foo; // expected-note {{requested here}}
         // expected-error-re@variant:* {{static_assert failed{{( due to requirement '2U[L]{0,2} < sizeof...\(_Types\)')?}} "Index out of bounds in std::variant_alternative<>"}}
     }
+
+  return 0;
 }
Index: test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
===================================================================
--- test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
+++ test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
@@ -59,10 +59,12 @@
   static_assert(std::__variant_npos<IndexT> == IndexLim::max(), "");
 }
 
-int main() {
+int main(int, char**) {
   test_index_type<unsigned char>();
   // This won't compile due to template depth issues.
   //test_index_type<unsigned short>();
   test_index_internals<unsigned char>();
   test_index_internals<unsigned short>();
+
+  return 0;
 }
Index: test/libcxx/utilities/variant/version.pass.cpp
===================================================================
--- test/libcxx/utilities/variant/version.pass.cpp
+++ test/libcxx/utilities/variant/version.pass.cpp
@@ -14,6 +14,8 @@
 #error _LIBCPP_VERSION not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/nothing_to_do.pass.cpp
===================================================================
--- test/nothing_to_do.pass.cpp
+++ test/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp
===================================================================
--- test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp
+++ test/std/algorithms/alg.c.library/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
@@ -46,7 +46,7 @@
         assert(ia[i] == ib[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -86,4 +86,6 @@
 // #if TEST_STD_VER > 17
 //     static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
@@ -49,7 +49,7 @@
         assert(ia[i] == ib[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
     test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
@@ -66,4 +66,6 @@
 // #if TEST_STD_VER > 17
 //     static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
@@ -53,7 +53,7 @@
         assert(ib[i] % 3 == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -93,4 +93,6 @@
 // #if TEST_STD_VER > 17
 //     static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
@@ -49,7 +49,7 @@
         assert(ia[i] == ib[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -89,4 +89,6 @@
 // #if TEST_STD_VER > 17
 //     static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
@@ -56,7 +56,7 @@
     assert(ia[3] == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test_char<forward_iterator<char*> >();
     test_char<bidirectional_iterator<char*> >();
@@ -71,4 +71,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
@@ -148,7 +148,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test_char<forward_iterator<char*> >();
     test_char<bidirectional_iterator<char*> >();
@@ -170,4 +170,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
@@ -51,7 +51,7 @@
     assert(ia[3] == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -61,4 +61,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
@@ -74,7 +74,7 @@
     test2<Iter, long double>();
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -84,4 +84,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
@@ -54,7 +54,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -127,4 +127,6 @@
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
@@ -54,7 +54,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
     test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
@@ -81,4 +81,6 @@
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
@@ -35,7 +35,7 @@
 #endif
 
 
-int main() {
+int main(int, char**) {
   {
     const int ia[] = {1, 2, 3, 4, 5, 6};
     unary_counting_predicate<is_odd, int> pred((is_odd()));
@@ -94,4 +94,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
@@ -93,9 +93,11 @@
         assert(!is_odd()(*i));
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
@@ -43,7 +43,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         const int ia[] = {1, 2, 3, 4, 6, 8, 5, 7};
@@ -68,4 +68,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
@@ -35,7 +35,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
         const int ia[] = {2, 4, 6, 8, 10};
@@ -89,4 +89,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
@@ -301,7 +301,7 @@
 
 #endif  // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<std::pair<int,int>*> >();
     test<random_access_iterator<std::pair<int,int>*> >();
@@ -310,4 +310,6 @@
 #if TEST_STD_VER >= 11
     test1<bidirectional_iterator<std::unique_ptr<int>*> >();
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
@@ -32,9 +32,11 @@
                             SampleIterator(oa), os, g);
 }
 
-int main() {
+int main(int, char**) {
   // expected-error-re@algorithm:* {{static_assert failed{{( due to requirement '.*')?}} "SampleIterator must meet the requirements of RandomAccessIterator"}}
   // expected-error@algorithm:* 2 {{does not provide a subscript operator}}
   // expected-error@algorithm:* {{invalid operands}}
   test<input_iterator<int *>, output_iterator<int *> >();
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
@@ -136,7 +136,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test<input_iterator, int, random_access_iterator, int>();
   test<forward_iterator, int, output_iterator, int>();
   test<forward_iterator, int, random_access_iterator, int>();
@@ -156,4 +156,6 @@
   test_small_population<input_iterator, int, random_access_iterator, int>();
   test_small_population<forward_iterator, int, output_iterator, int>();
   test_small_population<forward_iterator, int, random_access_iterator, int>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
@@ -48,7 +48,9 @@
   assert(expect_stable == !unstable);
 }
 
-int main() {
+int main(int, char**) {
   test_stability<forward_iterator<int *>, output_iterator<int *> >(true);
   test_stability<input_iterator<int *>, random_access_iterator<int *> >(false);
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
@@ -39,7 +39,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     int ia[]  = {1, 2, 3, 4};
     int ia1[] = {1, 4, 3, 2};
@@ -57,4 +57,5 @@
     test_with_iterator<random_access_iterator<int*> >();
     test_with_iterator<int*>();
 
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
@@ -51,8 +51,9 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test_with_iterator<random_access_iterator<int*> >();
     test_with_iterator<int*>();
-}
\ No newline at end of file
+    return 0;
+}
Index: test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     int ia1[] = {2, 7, 1, 4, 3, 6, 5, 10, 9, 8};
@@ -31,4 +31,6 @@
     std::shuffle(ia, ia+sa, std::move(g));
     LIBCPP_ASSERT(std::equal(ia, ia+sa, ia2));
     assert(std::is_permutation(ia, ia+sa, ia2));
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
@@ -73,7 +73,7 @@
 }
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -90,4 +90,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
@@ -50,7 +50,7 @@
     assert(ib[5] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -85,4 +85,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
@@ -55,7 +55,7 @@
     assert(ib[5] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -90,4 +90,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
@@ -88,7 +88,7 @@
 }
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -105,4 +105,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
@@ -47,7 +47,7 @@
     assert(ia[4] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -57,4 +57,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
@@ -54,7 +54,7 @@
     assert(ib[4] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -89,4 +89,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
@@ -58,7 +58,7 @@
     assert(ib[4] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -93,4 +93,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
@@ -50,7 +50,7 @@
     assert(ia[4] == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -60,4 +60,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
@@ -51,9 +51,11 @@
     assert(id[3] == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
@@ -72,7 +72,7 @@
     assert(jd[3] == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const int*>, output_iterator<int*> >();
     test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
@@ -95,4 +95,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
@@ -419,7 +419,7 @@
 
 #endif  // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -434,4 +434,6 @@
     test1<std::unique_ptr<int>*>();
 
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
@@ -128,7 +128,7 @@
     assert(ib[3] == 3);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const int*>, output_iterator<int*> >();
     test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
@@ -151,4 +151,6 @@
 // #if TEST_STD_VER > 17
 //    static_assert(test_constexpr());
 // #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp
@@ -16,11 +16,13 @@
 #include <algorithm>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int i = 1;
     int j = 2;
     std::iter_swap(&i, &j);
     assert(i == 2);
     assert(j == 1);
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
@@ -105,7 +105,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*>, forward_iterator<int*> >();
     test<forward_iterator<int*>, bidirectional_iterator<int*> >();
@@ -150,4 +150,6 @@
 #endif // TEST_STD_VER >= 11
 
     test2();
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
@@ -56,7 +56,7 @@
     assert(ib[4] == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
@@ -236,4 +236,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
@@ -57,7 +57,7 @@
     assert(ib[4] == 5);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();
@@ -97,4 +97,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
@@ -181,7 +181,7 @@
 }
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -198,4 +198,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
@@ -105,7 +105,7 @@
     assert(ji[2] == 2);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -140,4 +140,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
@@ -133,7 +133,7 @@
     assert(count_equal::count == si-1);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -168,4 +168,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
@@ -223,7 +223,7 @@
 }
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
@@ -240,4 +240,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
@@ -30,7 +30,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -47,4 +47,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
@@ -34,7 +34,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -54,4 +54,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
@@ -36,7 +36,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         int ia[] = {2, 4, 6, 8};
@@ -58,4 +58,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
@@ -36,7 +36,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         int ia[] = {2, 4, 6, 8};
@@ -66,4 +66,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
@@ -29,7 +29,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -43,4 +43,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
@@ -36,7 +36,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -53,4 +53,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
@@ -44,7 +44,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -88,4 +88,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
@@ -58,7 +58,7 @@
     return a == b;
 }
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -114,4 +114,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
@@ -62,7 +62,7 @@
     assert(std::find_end(Iter1(ia), Iter1(ia), Iter2(b), Iter2(b+1)) == Iter1(ia));
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
@@ -77,4 +77,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
@@ -92,7 +92,7 @@
     assert(count_equal::count <= 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
@@ -107,4 +107,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
@@ -38,7 +38,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -69,4 +69,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
@@ -40,7 +40,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -75,4 +75,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
@@ -29,7 +29,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -42,4 +42,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
@@ -37,7 +37,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -53,4 +53,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
@@ -37,7 +37,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -53,4 +53,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
@@ -40,7 +40,7 @@
     void operator()(int& i) {++i; ++count;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef input_iterator<int*> Iter;
     int ia[] = {0, 1, 2, 3, 4, 5};
@@ -76,4 +76,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
@@ -37,7 +37,7 @@
     void operator()(int& i) {++i; ++count;}
 };
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
@@ -51,4 +51,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
@@ -35,7 +35,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         const int ia[] = {0};
@@ -618,4 +618,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
@@ -55,7 +55,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         const int ia[] = {0};
@@ -769,4 +769,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
@@ -36,7 +36,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         int ia[] = {2, 4, 6, 8};
@@ -66,4 +66,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
@@ -95,7 +95,7 @@
     assert(std::search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk)) == Iter1(ij+6));
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
@@ -121,4 +121,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
@@ -79,7 +79,7 @@
     (void)std::search_n(Iter(ic), Iter(ic+sc), UserDefinedIntegral<unsigned>(0), 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -88,4 +88,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
@@ -158,7 +158,7 @@
     count_equal::count = 0;
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -167,4 +167,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
@@ -110,7 +110,7 @@
     assert(count_equal::count <= sh*3);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
@@ -125,4 +125,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
@@ -58,7 +58,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -89,4 +89,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
@@ -68,7 +68,7 @@
 #define HAS_FOUR_ITERATOR_VERSION
 #endif
 
-int main()
+int main(int, char**)
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
@@ -114,4 +114,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
@@ -525,11 +525,13 @@
     assert(std::is_heap(i246, i246+7) == (std::is_heap_until(i246, i246+7) == i246+7));
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
@@ -526,11 +526,13 @@
     assert(std::is_heap(i246, i246+7, std::greater<int>()) == (std::is_heap_until(i246, i246+7, std::greater<int>()) == i246+7));
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
@@ -525,11 +525,13 @@
     assert(std::is_heap_until(i246, i246+7) == i246+7);
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
@@ -526,11 +526,13 @@
     assert(std::is_heap_until(i246, i246+7, std::greater<int>()) == i246+6);
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
@@ -30,7 +30,7 @@
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(1);
@@ -38,4 +38,6 @@
     test(3);
     test(10);
     test(1000);
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
@@ -74,7 +74,7 @@
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(1);
@@ -97,4 +97,6 @@
     delete [] ia;
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
@@ -35,7 +35,9 @@
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(1000);
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
@@ -47,7 +47,7 @@
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(1000);
 
@@ -67,4 +67,6 @@
     delete [] ia;
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
@@ -34,7 +34,9 @@
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(1000);
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
@@ -45,7 +45,7 @@
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(1000);
 
@@ -64,4 +64,6 @@
     delete [] ia;
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
@@ -31,7 +31,7 @@
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(1);
@@ -39,4 +39,6 @@
     test(3);
     test(10);
     test(1000);
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
@@ -42,7 +42,7 @@
     delete [] ia;
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(1);
@@ -64,4 +64,6 @@
     delete [] ia;
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
@@ -61,7 +61,7 @@
     test(Iter(v.data()), Iter(v.data()+v.size()), M, false);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {0, 2, 4, 6};
     for (int* e = d; e <= d+4; ++e)
@@ -76,4 +76,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
@@ -62,7 +62,7 @@
     test(Iter(v.data()), Iter(v.data()+v.size()), M, false);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {6, 4, 2, 0};
     for (int* e = d; e <= d+4; ++e)
@@ -77,4 +77,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
@@ -69,7 +69,7 @@
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {0, 1, 2, 3};
     for (int* e = d; e <= d+4; ++e)
@@ -84,4 +84,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
@@ -68,7 +68,7 @@
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {3, 2, 1, 0};
     for (int* e = d; e <= d+4; ++e)
@@ -83,4 +83,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
@@ -64,7 +64,7 @@
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {0, 1, 2, 3};
     for (int* e = d; e <= d+4; ++e)
@@ -79,4 +79,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
@@ -64,7 +64,7 @@
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {3, 2, 1, 0};
     for (int* e = d; e <= d+4; ++e)
@@ -79,4 +79,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
@@ -61,7 +61,7 @@
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {0, 1, 2, 3};
     for (int* e = d; e <= d+4; ++e)
@@ -76,4 +76,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
@@ -64,7 +64,7 @@
         test(Iter(v.data()), Iter(v.data()+v.size()), x);
 }
 
-int main()
+int main(int, char**)
 {
     int d[] = {3, 2, 1, 0};
     for (int* e = d; e <= d+4; ++e)
@@ -79,4 +79,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.clamp/clamp.comp.pass.cpp
@@ -38,7 +38,7 @@
     assert(&std::clamp(v, lo, hi, c) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -123,4 +123,6 @@
     static_assert(std::clamp(x, y, z, std::greater<T>()) == y, "" );
     static_assert(std::clamp(y, x, z, std::greater<T>()) == y, "" );
     }
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
@@ -36,7 +36,7 @@
     assert(&std::clamp(a, lo, hi) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -121,4 +121,6 @@
     static_assert(std::clamp(x, y, z) == x, "" );
     static_assert(std::clamp(y, x, z) == x, "" );
     }
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
@@ -46,7 +46,7 @@
     assert(!std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3),  Iter2(ia),   Iter2(ia+sa)));
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -81,4 +81,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
@@ -51,7 +51,7 @@
     assert( std::lexicographical_compare(Iter1(ib+1), Iter1(ib+3),  Iter2(ia),   Iter2(ia+sa), c));
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -86,4 +86,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
@@ -96,7 +96,7 @@
     test<Iter>(1000);
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
@@ -107,4 +107,6 @@
     test<random_access_iterator<S*> >();
     test<S*>();
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
@@ -135,7 +135,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
@@ -167,4 +167,6 @@
 #endif  // TEST_STD_VER >= 11
 
     test_PR31166();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
@@ -89,7 +89,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -245,4 +245,6 @@
 //  Not yet - waiting on std::copy
 //     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
@@ -100,7 +100,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -256,4 +256,6 @@
 //  Not yet - waiting on std::copy
 //     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/max.pass.cpp
@@ -24,7 +24,7 @@
     assert(&std::max(a, b) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -52,4 +52,6 @@
     static_assert(std::max(y, x) == x, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
@@ -26,7 +26,7 @@
     assert(&std::max(a, b, c) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -54,4 +54,6 @@
     static_assert(std::max(y, x, std::greater<int>()) == y, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
@@ -71,7 +71,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -79,4 +79,6 @@
     test<const int*>();
 
     constexpr_test ();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
@@ -91,7 +91,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -100,4 +100,6 @@
     test_eq();
 
     constexpr_test();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int i = std::max({2, 3, 1});
     assert(i == 3);
@@ -40,4 +40,6 @@
     static_assert(std::max({3, 2, 1}) == 3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int i = std::max({2, 3, 1}, std::greater<int>());
     assert(i == 1);
@@ -41,4 +41,6 @@
     static_assert(std::max({3, 2, 1}, std::greater<int>()) == 1, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/min.pass.cpp
@@ -24,7 +24,7 @@
     assert(&std::min(a, b) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -52,4 +52,6 @@
     static_assert(std::min(y, x) == y, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
@@ -26,7 +26,7 @@
     assert(&std::min(a, b, c) == &x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -54,4 +54,6 @@
     static_assert(std::min(y, x, std::greater<int>()) == x, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
@@ -71,7 +71,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -79,4 +79,6 @@
     test<const int*>();
 
     constexpr_test();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
@@ -91,7 +91,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -100,4 +100,6 @@
     test_eq();
 
     constexpr_test();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int i = std::min({2, 3, 1});
     assert(i == 1);
@@ -40,4 +40,6 @@
     static_assert(std::min({3, 2, 1}) == 1, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     int i = std::min({2, 3, 1}, std::greater<int>());
     assert(i == 3);
@@ -41,4 +41,6 @@
     static_assert(std::min({3, 2, 1}, std::greater<int>()) == 3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
@@ -26,7 +26,7 @@
     assert(&p.second == &y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -60,4 +60,6 @@
     static_assert(p2.second == x, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
@@ -29,7 +29,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int x = 0;
@@ -63,4 +63,6 @@
     static_assert(p2.second == y, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
@@ -89,7 +89,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -97,4 +97,6 @@
     test<const int*>();
 
    constexpr_test();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
@@ -96,7 +96,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -104,4 +104,6 @@
     test<const int*>();
 
     constexpr_test();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert((std::minmax({1, 2, 3}) == std::pair<int, int>(1, 3)));
     assert((std::minmax({1, 3, 2}) == std::pair<int, int>(1, 3)));
@@ -37,4 +37,6 @@
     static_assert((std::minmax({3, 2, 1}) == std::pair<int, int>(1, 3)), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
@@ -35,7 +35,7 @@
     assert(pred.count() <= ((3 * il.size()) / 2));
 }
 
-int main()
+int main(int, char**)
 {
     assert((std::minmax({1, 2, 3}, std::greater<int>()) == std::pair<int, int>(3, 1)));
     assert((std::minmax({1, 3, 2}, std::greater<int>()) == std::pair<int, int>(3, 1)));
@@ -72,4 +72,6 @@
     static_assert((std::minmax({3, 2, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
@@ -16,7 +16,7 @@
 
 #include "test_iterators.h"
 
-int main() {
+int main(int, char**) {
   int arr[] = {1, 2, 3};
   const int *b = std::begin(arr), *e = std::end(arr);
   typedef input_iterator<const int*> Iter;
@@ -33,4 +33,6 @@
     std::minmax_element(Iter(b), Iter(e));
   }
 
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
@@ -50,7 +50,7 @@
     test_one(N, N-1);
 }
 
-int main()
+int main(int, char**)
 {
     int d = 0;
     std::nth_element(&d, &d, &d);
@@ -62,4 +62,6 @@
     test(997);
     test(1000);
     test(1009);
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
@@ -63,7 +63,7 @@
     test_one(N, N-1);
 }
 
-int main()
+int main(int, char**)
 {
     int d = 0;
     std::nth_element(&d, &d, &d);
@@ -85,4 +85,6 @@
     assert(static_cast<std::size_t>(*v[v.size()/2]) == v.size()/2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
@@ -57,9 +57,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
@@ -59,9 +59,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
@@ -57,9 +57,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
@@ -59,9 +59,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
@@ -62,7 +62,7 @@
     assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4)));
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -97,4 +97,6 @@
 #if TEST_STD_VER > 17
    static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
@@ -65,7 +65,7 @@
     assert(!std::includes(Iter1(ia), Iter1(ia+sa), Iter2(id), Iter2(id+4), std::less<int>()));
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -100,4 +100,6 @@
 #if TEST_STD_VER > 17
    static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
@@ -45,7 +45,7 @@
     assert(std::lexicographical_compare(ic, base(ce), irr, irr+srr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -196,4 +196,6 @@
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
@@ -47,7 +47,7 @@
     assert(std::lexicographical_compare(ic, base(ce), irr, irr+srr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -198,4 +198,6 @@
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
@@ -62,7 +62,7 @@
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -217,4 +217,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
@@ -65,7 +65,7 @@
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -220,4 +220,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
@@ -44,7 +44,7 @@
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -195,4 +195,6 @@
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
@@ -48,7 +48,7 @@
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -199,4 +199,6 @@
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
@@ -43,7 +43,7 @@
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -194,4 +194,6 @@
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
@@ -45,7 +45,7 @@
     assert(std::lexicographical_compare(ic, base(ce), ir, ir+sr) == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
@@ -196,4 +196,6 @@
     test<const int*, const int*, bidirectional_iterator<int*> >();
     test<const int*, const int*, random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
@@ -28,7 +28,7 @@
 #include "MoveOnly.h"
 
 
-int main()
+int main(int, char**)
 {
     std::vector<MoveOnly> lhs, rhs;
     lhs.push_back(MoveOnly(2));
@@ -42,4 +42,6 @@
 
     assert(res.size() == 1);
     assert(res[0].get() == 2);
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
@@ -182,7 +182,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -192,4 +192,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
@@ -183,7 +183,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -193,4 +193,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
@@ -182,7 +182,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -192,4 +192,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
@@ -183,7 +183,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
@@ -193,4 +193,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
@@ -75,7 +75,7 @@
     test_larger_sorts<Iter>(1009);
 }
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::partial_sort_copy(&i, &i, &i, &i+5);
@@ -85,4 +85,6 @@
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
@@ -79,7 +79,7 @@
     test_larger_sorts<Iter>(1009);
 }
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::partial_sort_copy(&i, &i, &i, &i+5);
@@ -89,4 +89,6 @@
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
@@ -53,7 +53,7 @@
     test_larger_sorts(N, N);
 }
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::partial_sort(&i, &i, &i);
@@ -66,4 +66,6 @@
     test_larger_sorts(997);
     test_larger_sorts(1000);
     test_larger_sorts(1009);
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
@@ -66,7 +66,7 @@
     test_larger_sorts(N, N);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int i = 0;
@@ -92,4 +92,6 @@
         assert(*v[i] == i);
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
@@ -130,7 +130,7 @@
     test_larger_sorts(N, N);
 }
 
-int main()
+int main(int, char**)
 {
     // test null range
     int d = 0;
@@ -152,4 +152,6 @@
     test_larger_sorts(997);
     test_larger_sorts(1000);
     test_larger_sorts(1009);
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
@@ -30,7 +30,7 @@
         {return *x < *y;}
 };
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int> v(1000);
@@ -53,4 +53,6 @@
     assert(*v[2] == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
@@ -130,7 +130,7 @@
     test_larger_sorts(N, N);
 }
 
-int main()
+int main(int, char**)
 {
     // test null range
     int d = 0;
@@ -152,4 +152,6 @@
     test_larger_sorts(997);
     test_larger_sorts(1000);
     test_larger_sorts(1009);
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
@@ -66,7 +66,7 @@
     assert(std::is_sorted(v.begin(), v.end()));
 }
 
-int main()
+int main(int, char**)
 {
     test();
 
@@ -82,4 +82,6 @@
     assert(*v[2] == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp
+++ test/std/algorithms/alg.sorting/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp
+++ test/std/algorithms/algorithms.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp
===================================================================
--- test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp
+++ test/std/atomics/atomics.fences/atomic_signal_fence.pass.cpp
@@ -14,7 +14,9 @@
 
 #include <atomic>
 
-int main()
+int main(int, char**)
 {
     std::atomic_signal_fence(std::memory_order_seq_cst);
+
+  return 0;
 }
Index: test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp
===================================================================
--- test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp
+++ test/std/atomics/atomics.fences/atomic_thread_fence.pass.cpp
@@ -14,7 +14,9 @@
 
 #include <atomic>
 
-int main()
+int main(int, char**)
 {
     std::atomic_thread_fence(std::memory_order_seq_cst);
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
===================================================================
--- test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
+++ test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f;
@@ -34,4 +34,6 @@
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
     }
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
+++ test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f; // uninitialized first
@@ -62,4 +62,6 @@
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
===================================================================
--- test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
+++ test/std/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f;
@@ -32,4 +32,6 @@
         assert(atomic_flag_test_and_set(&f) == 0);
         assert(f.test_and_set() == 1);
     }
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
+++ test/std/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f;
@@ -92,4 +92,6 @@
         assert(atomic_flag_test_and_set_explicit(&f, std::memory_order_seq_cst) == 0);
         assert(f.test_and_set() == 1);
     }
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/clear.pass.cpp
===================================================================
--- test/std/atomics/atomics.flag/clear.pass.cpp
+++ test/std/atomics/atomics.flag/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f; // uninitialized
@@ -76,4 +76,6 @@
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/copy_assign.fail.cpp
===================================================================
--- test/std/atomics/atomics.flag/copy_assign.fail.cpp
+++ test/std/atomics/atomics.flag/copy_assign.fail.cpp
@@ -15,9 +15,11 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f0;
     std::atomic_flag f;
     f = f0;
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/copy_ctor.fail.cpp
===================================================================
--- test/std/atomics/atomics.flag/copy_ctor.fail.cpp
+++ test/std/atomics/atomics.flag/copy_ctor.fail.cpp
@@ -15,8 +15,10 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f0;
     std::atomic_flag f(f0);
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp
===================================================================
--- test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp
+++ test/std/atomics/atomics.flag/copy_volatile_assign.fail.cpp
@@ -15,9 +15,11 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f0;
     volatile std::atomic_flag f;
     f = f0;
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/default.pass.cpp
===================================================================
--- test/std/atomics/atomics.flag/default.pass.cpp
+++ test/std/atomics/atomics.flag/default.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f;
     f.clear();
@@ -32,4 +32,6 @@
         assert(!zero.test_and_set());
         zero.~A();
     }
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/init.pass.cpp
===================================================================
--- test/std/atomics/atomics.flag/init.pass.cpp
+++ test/std/atomics/atomics.flag/init.pass.cpp
@@ -18,8 +18,10 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic_flag f = ATOMIC_FLAG_INIT;
     assert(f.test_and_set() == 0);
+
+  return 0;
 }
Index: test/std/atomics/atomics.flag/test_and_set.pass.cpp
===================================================================
--- test/std/atomics/atomics.flag/test_and_set.pass.cpp
+++ test/std/atomics/atomics.flag/test_and_set.pass.cpp
@@ -18,7 +18,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::atomic_flag f;
@@ -104,4 +104,6 @@
         assert(f.test_and_set(std::memory_order_seq_cst) == 0);
         assert(f.test_and_set(std::memory_order_seq_cst) == 1);
     }
+
+  return 0;
 }
Index: test/std/atomics/atomics.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/atomics/atomics.general/nothing_to_do.pass.cpp
+++ test/std/atomics/atomics.general/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/atomics/atomics.general/replace_failure_order.pass.cpp
===================================================================
--- test/std/atomics/atomics.general/replace_failure_order.pass.cpp
+++ test/std/atomics/atomics.general/replace_failure_order.pass.cpp
@@ -23,7 +23,7 @@
 
 #include <atomic>
 
-int main() {
+int main(int, char**) {
     std::atomic<int> i;
     volatile std::atomic<int> v;
     int exp = 0;
Index: test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
===================================================================
--- test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
+++ test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
@@ -134,4 +134,4 @@
     static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));
 }
 
-int main() { run(); }
+int main(int, char**) { run(); return 0; }
Index: test/std/atomics/atomics.lockfree/lockfree.pass.cpp
===================================================================
--- test/std/atomics/atomics.lockfree/lockfree.pass.cpp
+++ test/std/atomics/atomics.lockfree/lockfree.pass.cpp
@@ -24,7 +24,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(ATOMIC_BOOL_LOCK_FREE == 0 ||
            ATOMIC_BOOL_LOCK_FREE == 1 ||
@@ -56,4 +56,6 @@
     assert(ATOMIC_POINTER_LOCK_FREE == 0 ||
            ATOMIC_POINTER_LOCK_FREE == 1 ||
            ATOMIC_POINTER_LOCK_FREE == 2);
+
+  return 0;
 }
Index: test/std/atomics/atomics.order/kill_dependency.pass.cpp
===================================================================
--- test/std/atomics/atomics.order/kill_dependency.pass.cpp
+++ test/std/atomics/atomics.order/kill_dependency.pass.cpp
@@ -15,8 +15,10 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::kill_dependency(5) == 5);
     assert(std::kill_dependency(-5.5) == -5.5);
+
+  return 0;
 }
Index: test/std/atomics/atomics.order/memory_order.pass.cpp
===================================================================
--- test/std/atomics/atomics.order/memory_order.pass.cpp
+++ test/std/atomics/atomics.order/memory_order.pass.cpp
@@ -19,7 +19,7 @@
 #include <atomic>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::memory_order_relaxed == 0);
     assert(std::memory_order_consume == 1);
@@ -29,4 +29,6 @@
     assert(std::memory_order_seq_cst == 5);
     std::memory_order o = std::memory_order_seq_cst;
     assert(o == 5);
+
+  return 0;
 }
Index: test/std/atomics/atomics.syn/nothing_to_do.pass.cpp
===================================================================
--- test/std/atomics/atomics.syn/nothing_to_do.pass.cpp
+++ test/std/atomics/atomics.syn/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.generic/address.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.generic/address.pass.cpp
+++ test/std/atomics/atomics.types.generic/address.pass.cpp
@@ -136,7 +136,9 @@
     do_test<volatile A, T>();
 }
 
-int main()
+int main(int, char**)
 {
     test<std::atomic<int*>, int*>();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.generic/bool.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.generic/bool.pass.cpp
+++ test/std/atomics/atomics.types.generic/bool.pass.cpp
@@ -58,7 +58,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         volatile std::atomic<bool> obj(true);
@@ -232,4 +232,6 @@
         assert(zero == false);
         zero.~A();
     }
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
+++ test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
@@ -39,7 +39,7 @@
 #include <type_traits>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::atomic<  std::int_least8_t>,   std::atomic_int_least8_t>::value), "");
     static_assert((std::is_same<std::atomic< std::uint_least8_t>,  std::atomic_uint_least8_t>::value), "");
@@ -65,4 +65,6 @@
     static_assert((std::is_same<std::atomic<std::ptrdiff_t>, std::atomic_ptrdiff_t>::value), "");
     static_assert((std::is_same<std::atomic< std::intmax_t>,  std::atomic_intmax_t>::value), "");
     static_assert((std::is_same<std::atomic<std::uintmax_t>, std::atomic_uintmax_t>::value), "");
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.generic/integral.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.generic/integral.pass.cpp
+++ test/std/atomics/atomics.types.generic/integral.pass.cpp
@@ -167,7 +167,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test<std::atomic_char, char>();
     test<std::atomic_schar, signed char>();
@@ -220,4 +220,6 @@
     test<volatile std::atomic_uint32_t, uint32_t>();
     test<volatile std::atomic_int64_t,   int64_t>();
     test<volatile std::atomic_uint64_t, uint64_t>();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
+++ test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
@@ -40,7 +40,7 @@
 #include <atomic>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::atomic<char>, std::atomic_char>::value), "");
     static_assert((std::is_same<std::atomic<signed char>, std::atomic_schar>::value), "");
@@ -71,4 +71,6 @@
     static_assert((std::is_same<std::atomic<uint32_t>,  std::atomic_uint32_t>::value), "");
     static_assert((std::is_same<std::atomic<int64_t>,   std::atomic_int64_t>::value), "");
     static_assert((std::is_same<std::atomic<uint64_t>,  std::atomic_uint64_t>::value), "");
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
===================================================================
--- test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
+++ test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp
@@ -63,7 +63,9 @@
     std::atomic<T> t0(t);
 }
 
-int main()
+int main(int, char**)
 {
     test(NotTriviallyCopyable(42));
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
+++ test/std/atomics/atomics.types.generic/trivially_copyable.pass.cpp
@@ -68,9 +68,11 @@
     std::atomic<T> t0(t);
     }
 
-int main()
+int main(int, char**)
 {
     test(TriviallyCopyable(42));
     test(std::this_thread::get_id());
     test(std::chrono::nanoseconds(2));
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.arith/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.general/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.pointer/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
@@ -55,7 +55,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
@@ -62,7 +62,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
@@ -56,7 +56,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
@@ -64,7 +64,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
@@ -41,7 +41,9 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
@@ -43,7 +43,9 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp
@@ -74,9 +74,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp
@@ -79,9 +79,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp
@@ -44,7 +44,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp
@@ -46,7 +46,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp
@@ -44,7 +44,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp
@@ -46,7 +46,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp
@@ -74,9 +74,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp
@@ -79,9 +79,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
     testp<int*>();
     testp<const int*>();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp
@@ -44,7 +44,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp
@@ -46,7 +46,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachIntegralType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
@@ -38,7 +38,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
@@ -40,8 +40,10 @@
     char _[4];
 };
 
-int main()
+int main(int, char**)
 {
     TestFn<A>()();
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
@@ -38,7 +38,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
@@ -38,7 +38,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
@@ -38,7 +38,9 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
@@ -38,7 +38,9 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     TestEachAtomicType<TestFn>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp
@@ -17,8 +17,10 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::atomic<int> v = ATOMIC_VAR_INIT(5);
     assert(v == 5);
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp
@@ -56,8 +56,10 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     TestFunc<UserType>()();
     TestEachIntegralType<TestFunc>()();
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp
+++ test/std/atomics/atomics.types.operations/atomics.types.operations.templ/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp
===================================================================
--- test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp
+++ test/std/atomics/atomics.types.operations/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/associative/iterator_types.pass.cpp
===================================================================
--- test/std/containers/associative/iterator_types.pass.cpp
+++ test/std/containers/associative/iterator_types.pass.cpp
@@ -50,7 +50,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef std::map<int, int> Map;
     typedef std::pair<const int, int> ValueTp;
@@ -127,4 +127,6 @@
     testSet<Set, ValueTp, min_pointer<const ValueTp>>();
   }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
===================================================================
--- test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
+++ test/std/containers/associative/map/PR28469_undefined_behavior_segfault.sh.cpp
@@ -24,7 +24,9 @@
     F() { m[42] = &dummy; }
 };
 
-int main() {
+int main(int, char**) {
     F f;
     f = F();
+
+  return 0;
 }
Index: test/std/containers/associative/map/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/associative/map/allocator_mismatch.fail.cpp
+++ test/std/containers/associative/map/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <map>
 
-int main()
+int main(int, char**)
 {
     std::map<int, int, std::less<int>, std::allocator<long> > m;
+
+  return 0;
 }
Index: test/std/containers/associative/map/compare.pass.cpp
===================================================================
--- test/std/containers/associative/map/compare.pass.cpp
+++ test/std/containers/associative/map/compare.pass.cpp
@@ -24,7 +24,7 @@
   bool operator< (const Key&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::map<Key, int> MapT;
     typedef MapT::iterator Iter;
@@ -48,4 +48,6 @@
         assert(!result2.second);
         assert(map[Key(0)] == 42);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/gcc_workaround.pass.cpp
===================================================================
--- test/std/containers/associative/map/gcc_workaround.pass.cpp
+++ test/std/containers/associative/map/gcc_workaround.pass.cpp
@@ -15,7 +15,4 @@
 using std::set;
 using std::multiset;
 
-int main(void)
-{
-       return 0;
-}
+int main(int, char**) { return 0; }
Index: test/std/containers/associative/map/incomplete_type.pass.cpp
===================================================================
--- test/std/containers/associative/map/incomplete_type.pass.cpp
+++ test/std/containers/associative/map/incomplete_type.pass.cpp
@@ -23,6 +23,8 @@
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.access/at.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.access/at.pass.cpp
+++ test/std/containers/associative/map/map.access/at.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -160,4 +160,6 @@
         assert(m.size() == 7);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.access/empty.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.access/empty.fail.cpp
+++ test/std/containers/associative/map/map.access/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::map<int, int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.access/empty.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.access/empty.pass.cpp
+++ test/std/containers/associative/map/map.access/empty.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double> M;
@@ -39,4 +39,6 @@
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.access/index_key.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.access/index_key.pass.cpp
+++ test/std/containers/associative/map/map.access/index_key.pass.cpp
@@ -23,7 +23,7 @@
 #include "container_test_types.h"
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -139,4 +139,6 @@
     assert(m.size() == 8);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
+++ test/std/containers/associative/map/map.access/index_rv_key.pass.cpp
@@ -23,7 +23,7 @@
 #include "min_allocator.h"
 #include "container_test_types.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::map<MoveOnly, double> m;
@@ -76,4 +76,6 @@
             }
         }
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.access/index_tuple.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.access/index_tuple.pass.cpp
+++ test/std/containers/associative/map/map.access/index_tuple.pass.cpp
@@ -22,9 +22,11 @@
 #include <tuple>
 
 
-int main()
+int main(int, char**)
 {
     using namespace std;
     map<tuple<int,int>, size_t> m;
     m[make_tuple(2,3)]=7;
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.access/iterator.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.access/iterator.pass.cpp
+++ test/std/containers/associative/map/map.access/iterator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -225,4 +225,6 @@
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.access/max_size.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.access/max_size.pass.cpp
+++ test/std/containers/associative/map/map.access/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::pair<const int, int> KV;
   {
@@ -47,4 +47,6 @@
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.access/size.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.access/size.pass.cpp
+++ test/std/containers/associative/map/map.access/size.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double> M;
@@ -55,4 +55,6 @@
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/alloc.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/alloc.pass.cpp
+++ test/std/containers/associative/map/map.cons/alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::less<int> C;
@@ -46,4 +46,6 @@
     assert(m.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
+++ test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -69,4 +69,6 @@
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/compare.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/compare.pass.cpp
+++ test/std/containers/associative/map/map.cons/compare.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > C;
@@ -38,4 +38,6 @@
     assert(m.key_comp() == C(3));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
+++ test/std/containers/associative/map/map.cons/compare_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > C;
@@ -50,4 +50,6 @@
     assert(m.get_allocator() == A{});
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
+++ test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::map<int, int, Comp<int> > m;
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/copy.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/copy.pass.cpp
+++ test/std/containers/associative/map/map.cons/copy.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -126,4 +126,6 @@
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
+++ test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -125,4 +125,6 @@
     assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
+++ test/std/containers/associative/map/map.cons/copy_assign.pass.cpp
@@ -108,7 +108,7 @@
     }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -337,4 +337,6 @@
     }
     assert(balanced_allocs());
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/default.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/default.pass.cpp
+++ test/std/containers/associative/map/map.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::map<int, double> m;
@@ -50,4 +50,6 @@
     assert(m.begin() == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
+++ test/std/containers/associative/map/map.cons/default_noexcept.pass.cpp
@@ -33,7 +33,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
 #if defined(_LIBCPP_VERSION)
@@ -54,4 +54,6 @@
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/default_recursive.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/default_recursive.pass.cpp
+++ test/std/containers/associative/map/map.cons/default_recursive.pass.cpp
@@ -23,6 +23,8 @@
     std::map<int, X>::const_reverse_iterator cri;
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@
     bool operator()(const T&, const T&) const noexcept { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -48,4 +48,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
+++ test/std/containers/associative/map/map.cons/initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -61,4 +61,6 @@
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
+++ test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -63,4 +63,6 @@
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.key_comp() == C(3));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
+++ test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -116,4 +116,6 @@
     assert(m.key_comp() == C(3));
     assert(m.get_allocator() == a);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
+++ test/std/containers/associative/map/map.cons/iter_iter.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -64,4 +64,6 @@
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
+++ test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -69,4 +69,6 @@
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
+++ test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -119,4 +119,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/move.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/move.pass.cpp
+++ test/std/containers/associative/map/map.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -114,4 +114,6 @@
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
+++ test/std/containers/associative/map/map.cons/move_alloc.pass.cpp
@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 #include "Counter.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -268,4 +268,6 @@
         assert(m3.key_comp() == C(5));
         LIBCPP_ASSERT(m1.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/move_assign.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/move_assign.pass.cpp
+++ test/std/containers/associative/map/map.cons/move_assign.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -184,4 +184,6 @@
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/associative/map/map.cons/move_assign_noexcept.pass.cpp
@@ -33,7 +33,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -54,4 +54,6 @@
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
+++ test/std/containers/associative/map/map.cons/move_noexcept.pass.cpp
@@ -31,7 +31,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     typedef std::pair<const MoveOnly, MoveOnly> V;
@@ -52,4 +52,6 @@
         typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.erasure/erase_if.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.erasure/erase_if.pass.cpp
+++ test/std/containers/associative/map/map.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::map<int, int>>();
     test<std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>>> ();
@@ -74,5 +74,7 @@
 
     test<std::map<long, short>>();
     test<std::map<short, double>>();
+
+  return 0;
 }
 
Index: test/std/containers/associative/map/map.modifiers/clear.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/clear.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -62,4 +62,6 @@
         assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, DefaultOnly> M;
@@ -159,4 +159,6 @@
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/emplace_hint.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, DefaultOnly> M;
@@ -154,4 +154,6 @@
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/erase_iter.pass.cpp
@@ -25,7 +25,7 @@
 
 bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -255,4 +255,6 @@
             c.erase(it);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/erase_iter_iter.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -153,4 +153,6 @@
         assert(i == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/erase_key.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -271,4 +271,6 @@
         assert(s == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/extract_iterator.pass.cpp
@@ -40,7 +40,7 @@
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using map_type = std::map<int, int>;
@@ -63,4 +63,6 @@
         min_alloc_map m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
         test(m);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/extract_key.pass.cpp
@@ -45,7 +45,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::map<int, int> m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}};
@@ -72,4 +72,6 @@
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
@@ -21,10 +21,12 @@
 #include "container_test_types.h"
 #include "../../../map_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMapInsert<TCT::map<> >();
   testMapInsertHint<TCT::map<> >();
   testMapEmplace<TCT::map<> >();
   testMapEmplaceHint<TCT::map<> >();
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_cv.pass.cpp
@@ -59,7 +59,7 @@
     assert(r.first->second == 3.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_cv_test<std::map<int, double> >();
 #if TEST_STD_VER >= 11
@@ -68,4 +68,6 @@
         do_insert_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -65,4 +65,6 @@
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_iter_cv.pass.cpp
@@ -55,7 +55,7 @@
     assert(r->second == 3.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_iter_cv_test<std::map<int, double> >();
 #if TEST_STD_VER >= 11
@@ -64,4 +64,6 @@
         do_insert_iter_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::map<int, double> M;
@@ -73,4 +73,6 @@
         assert(next(m.begin(), 2)->second == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_iter_rv.pass.cpp
@@ -53,7 +53,7 @@
     assert(r->first == 3);
     assert(r->second == 3);
 }
-int main()
+int main(int, char**)
 {
     do_insert_iter_rv_test<std::map<int, MoveOnly>, std::pair<int, MoveOnly>>();
     do_insert_iter_rv_test<std::map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
@@ -94,4 +94,6 @@
         assert(r->second == 3);
     }
 
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp
@@ -75,10 +75,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::map<int, int> m;
     test(m);
     std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp
@@ -54,10 +54,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::map<int, int> m;
     test(m);
     std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_or_assign.pass.cpp
@@ -56,7 +56,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     { // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
         typedef std::map<int, Moveable> M;
@@ -181,4 +181,6 @@
         assert(r->first.get()  == 3);  // key
         assert(r->second.get() == 5);  // value
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/insert_rv.pass.cpp
@@ -59,7 +59,7 @@
     assert(r.first->second == 3);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_rv_test<std::map<int, MoveOnly>, std::pair<int, MoveOnly>>();
     do_insert_rv_test<std::map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
@@ -103,4 +103,6 @@
         assert(r.first->first == 3);
         assert(r.first->second == 3);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/merge.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/merge.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/merge.pass.cpp
@@ -49,7 +49,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::map<int, int> src{{1, 0}, {3, 0}, {5, 0}};
@@ -146,4 +146,5 @@
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
Index: test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
+++ test/std/containers/associative/map/map.modifiers/try.emplace.pass.cpp
@@ -54,7 +54,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     { // pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
         typedef std::map<int, Moveable> M;
@@ -178,4 +178,6 @@
         assert(r->first.get()  == 3); // key
         assert(r->second.get() == 4); // value
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/count.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/count.pass.cpp
+++ test/std/containers/associative/map/map.ops/count.pass.cpp
@@ -20,7 +20,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -190,4 +190,6 @@
     assert(r == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/count0.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/count0.pass.cpp
+++ test/std/containers/associative/map/map.ops/count0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -35,4 +35,6 @@
     typedef std::map<int, double, transparent_less_not_referenceable> M;
     assert(M().count(C2Int{5}) == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/count1.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/count1.fail.cpp
+++ test/std/containers/associative/map/map.ops/count1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
Index: test/std/containers/associative/map/map.ops/count2.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/count2.fail.cpp
+++ test/std/containers/associative/map/map.ops/count2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
Index: test/std/containers/associative/map/map.ops/count3.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/count3.fail.cpp
+++ test/std/containers/associative/map/map.ops/count3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
Index: test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
+++ test/std/containers/associative/map/map.ops/count_transparent.pass.cpp
@@ -40,10 +40,12 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   std::map<std::pair<int, int>, int, Comp> s{
       {{2, 1}, 1}, {{1, 2}, 2}, {{1, 3}, 3}, {{1, 4}, 4}, {{2, 2}, 5}};
 
   auto cnt = s.count(1);
   assert(cnt == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/equal_range.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/equal_range.pass.cpp
+++ test/std/containers/associative/map/map.ops/equal_range.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -487,4 +487,6 @@
     assert(r.second == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
+++ test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -41,4 +41,6 @@
     P result = example.equal_range(C2Int{5});
     assert(result.first == result.second);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
+++ test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
Index: test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
+++ test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
Index: test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
+++ test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
Index: test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
+++ test/std/containers/associative/map/map.ops/equal_range_transparent.pass.cpp
@@ -43,7 +43,7 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   std::map<std::pair<int, int>, int, Comp> s{
       {{2, 1}, 1}, {{1, 2}, 2}, {{1, 3}, 3}, {{1, 4}, 4}, {{2, 2}, 5}};
 
@@ -56,4 +56,6 @@
   }
 
   assert(nels == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/find.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/find.pass.cpp
+++ test/std/containers/associative/map/map.ops/find.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -257,4 +257,6 @@
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/find0.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/find0.pass.cpp
+++ test/std/containers/associative/map/map.ops/find0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -37,4 +37,6 @@
     M example;
     assert(example.find(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/find1.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/find1.fail.cpp
+++ test/std/containers/associative/map/map.ops/find1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
Index: test/std/containers/associative/map/map.ops/find2.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/find2.fail.cpp
+++ test/std/containers/associative/map/map.ops/find2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
Index: test/std/containers/associative/map/map.ops/find3.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/find3.fail.cpp
+++ test/std/containers/associative/map/map.ops/find3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
Index: test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
+++ test/std/containers/associative/map/map.ops/lower_bound.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -369,4 +369,6 @@
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
+++ test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -37,4 +37,6 @@
     M example;
     assert(example.lower_bound(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
+++ test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
Index: test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
+++ test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
Index: test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
+++ test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
Index: test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
+++ test/std/containers/associative/map/map.ops/upper_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -332,4 +332,6 @@
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
+++ test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less> M;
@@ -37,4 +37,6 @@
     M example;
     assert(example.upper_bound(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
+++ test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
Index: test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
+++ test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
Index: test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
===================================================================
--- test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
+++ test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
Index: test/std/containers/associative/map/map.special/member_swap.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.special/member_swap.pass.cpp
+++ test/std/containers/associative/map/map.special/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -172,4 +172,6 @@
     }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
+++ test/std/containers/associative/map/map.special/non_member_swap.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -277,4 +277,6 @@
         assert(m2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
+++ test/std/containers/associative/map/map.special/swap_noexcept.pass.cpp
@@ -91,7 +91,7 @@
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -138,4 +138,6 @@
 #endif // _LIBCPP_VERSION
 #endif
 
+
+  return 0;
 }
Index: test/std/containers/associative/map/types.pass.cpp
===================================================================
--- test/std/containers/associative/map/types.pass.cpp
+++ test/std/containers/associative/map/types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::map<int, double> C;
@@ -66,4 +66,6 @@
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/allocator_mismatch.fail.cpp
+++ test/std/containers/associative/multimap/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <map>
 
-int main()
+int main(int, char**)
 {
     std::multimap<int, int, std::less<int>, std::allocator<long> > m;
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/empty.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/empty.fail.cpp
+++ test/std/containers/associative/multimap/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::multimap<int, int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/empty.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/empty.pass.cpp
+++ test/std/containers/associative/multimap/empty.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> M;
@@ -39,4 +39,6 @@
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/incomplete_type.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/incomplete_type.pass.cpp
+++ test/std/containers/associative/multimap/incomplete_type.pass.cpp
@@ -23,6 +23,8 @@
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/iterator.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/iterator.pass.cpp
+++ test/std/containers/associative/multimap/iterator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -229,4 +229,6 @@
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/max_size.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/max_size.pass.cpp
+++ test/std/containers/associative/multimap/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::pair<const int, int> KV;
   {
@@ -47,4 +47,6 @@
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::less<int> C;
@@ -46,4 +46,6 @@
     assert(m.get_allocator() == A{});
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> C;
@@ -79,4 +79,6 @@
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > C;
@@ -38,4 +38,6 @@
     assert(m.key_comp() == C(3));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/compare_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > C;
@@ -50,4 +50,6 @@
     assert(m.get_allocator() == A{});
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
+++ test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::multimap<int, int, Comp<int> > m;
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -99,4 +99,6 @@
         assert(mo.key_comp() == C(5));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -98,4 +98,6 @@
     assert(mo.key_comp() == C(5));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<const int, double> V;
@@ -121,4 +121,6 @@
         assert(mo.key_comp() == C(5));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::multimap<int, double> m;
@@ -50,4 +50,6 @@
     assert(m.begin() == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp
@@ -33,7 +33,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
 #if defined(_LIBCPP_VERSION)
@@ -54,4 +54,6 @@
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/default_recursive.pass.cpp
@@ -23,6 +23,8 @@
     std::multimap<int, X>::const_reverse_iterator cri;
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -48,4 +48,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> C;
@@ -77,4 +77,6 @@
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > Cmp;
@@ -85,4 +85,6 @@
     assert(*++i == V(3, 2));
     assert(m.key_comp() == Cmp(4));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > Cmp;
@@ -155,4 +155,6 @@
     assert(m.key_comp() == Cmp(4));
     assert(m.get_allocator() == A{});
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -109,4 +109,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -82,4 +82,6 @@
     assert(*next(m.begin(), 8) == V(3, 2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<const int, double> V;
@@ -118,4 +118,6 @@
     assert(*next(m.begin(), 8) == V(3, 2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -126,4 +126,6 @@
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp
@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 #include "Counter.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -268,4 +268,6 @@
         assert(m3.key_comp() == C(5));
         LIBCPP_ASSERT(m1.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/move_assign.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
@@ -184,4 +184,6 @@
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/move_assign_noexcept.pass.cpp
@@ -33,7 +33,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -54,4 +54,6 @@
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
+++ test/std/containers/associative/multimap/multimap.cons/move_noexcept.pass.cpp
@@ -31,7 +31,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     typedef std::pair<const MoveOnly, MoveOnly> V;
@@ -52,4 +52,6 @@
         typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp
+++ test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp
@@ -77,7 +77,7 @@
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::multimap<int, int>>();
     test<std::multimap<int, int, std::less<int>, min_allocator<std::pair<const int, int>>>> ();
@@ -85,4 +85,6 @@
 
     test<std::multimap<long, short>>();
     test<std::multimap<short, double>>();
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -62,4 +62,6 @@
         assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/emplace.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, DefaultOnly> M;
@@ -144,4 +144,6 @@
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/emplace_hint.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, DefaultOnly> M;
@@ -154,4 +154,6 @@
         assert(m.begin()->first == 2);
         assert(m.begin()->second == 3.5);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/erase_iter.pass.cpp
@@ -25,7 +25,7 @@
 
 bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -297,4 +297,6 @@
             c.erase(it);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/erase_iter_iter.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -153,4 +153,6 @@
         assert(i == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/erase_key.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -149,4 +149,6 @@
         assert(i == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/extract_iterator.pass.cpp
@@ -40,7 +40,7 @@
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using map_type = std::multimap<int, int>;
@@ -63,4 +63,6 @@
         min_alloc_map m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
         test(m);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/extract_key.pass.cpp
@@ -45,7 +45,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::multimap<int, int> m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}};
@@ -72,4 +72,6 @@
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/insert_allocator_requirements.pass.cpp
@@ -20,8 +20,10 @@
 #include "../../../map_allocator_requirement_test_templates.h"
 
 
-int main()
+int main(int, char**)
 {
   testMultimapInsert<TCT::multimap<> >();
   testMultimapInsertHint<TCT::multimap<> >();
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/insert_cv.pass.cpp
@@ -53,7 +53,7 @@
     assert(r->second == 3.5);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> Container;
@@ -65,4 +65,6 @@
         do_insert_test<Container>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> C;
@@ -85,4 +85,6 @@
     assert(*++i == V(3, 2));
     assert(*++i == V(3, 1.5));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/insert_iter_cv.pass.cpp
@@ -54,7 +54,7 @@
     assert(r->second == 4.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_hint_test<std::multimap<int, double> >();
 #if TEST_STD_VER >= 11
@@ -63,4 +63,6 @@
         do_insert_hint_test<M>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multimap<int, double> M;
@@ -97,4 +97,6 @@
         assert(next(m.begin(), 8)->second == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/insert_iter_rv.pass.cpp
@@ -54,7 +54,7 @@
     assert(r->second == 2);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_rv_test<std::multimap<int, MoveOnly>, std::pair<int, MoveOnly> >();
     do_insert_rv_test<std::multimap<int, MoveOnly>, std::pair<const int, MoveOnly> >();
@@ -95,4 +95,6 @@
         assert(r->first == 3);
         assert(r->second == 2);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/insert_node_type.pass.cpp
@@ -68,10 +68,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::multimap<int, int> m;
     test(m);
     std::multimap<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/insert_node_type_hint.pass.cpp
@@ -54,10 +54,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::multimap<int, int> m;
     test(m);
     std::multimap<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/insert_rv.pass.cpp
@@ -54,7 +54,7 @@
     assert(r->second == 3);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_rv_test<std::multimap<int, MoveOnly>>();
     {
@@ -89,4 +89,6 @@
         assert(r->first == 3);
         assert(r->second == 3);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
+++ test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
@@ -49,7 +49,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::multimap<int, int> src{{1, 0}, {3, 0}, {5, 0}};
@@ -146,4 +146,5 @@
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/count.pass.cpp
@@ -20,7 +20,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -172,4 +172,6 @@
     assert(r == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -35,4 +35,6 @@
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
     assert(M().count(C2Int{5}) == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
Index: test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_private> M;
 
Index: test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
Index: test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/count_transparent.pass.cpp
@@ -40,10 +40,12 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   std::multimap<std::pair<int, int>, int, Comp> s{
       {{2, 1}, 1}, {{1, 1}, 2}, {{1, 1}, 3}, {{1, 1}, 4}, {{2, 2}, 5}};
 
   auto cnt = s.count(1);
   assert(cnt == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -283,4 +283,6 @@
     assert(r.second == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -41,4 +41,6 @@
     P result = example.equal_range(C2Int{5});
     assert(result.first == result.second);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
Index: test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
Index: test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
Index: test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/equal_range_transparent.pass.cpp
@@ -43,7 +43,7 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   std::multimap<std::pair<int, int>, int, Comp> s{
       {{2, 1}, 1}, {{1, 1}, 2}, {{1, 1}, 3}, {{1, 1}, 4}, {{2, 2}, 5}};
 
@@ -56,4 +56,6 @@
   }
 
   assert(nels == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/find.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -219,4 +219,6 @@
     assert(r == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -37,4 +37,6 @@
     M example;
     assert(example.find(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
Index: test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
Index: test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
Index: test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/lower_bound.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -233,4 +233,6 @@
     }
 
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -37,4 +37,6 @@
     M example;
     assert(example.lower_bound(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
Index: test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
Index: test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
Index: test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/upper_bound.pass.cpp
@@ -21,7 +21,7 @@
 #include "private_constructor.hpp"
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -232,4 +232,6 @@
     }
 
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
+++ test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "is_transparent.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
@@ -37,4 +37,6 @@
     M example;
     assert(example.upper_bound(C2Int{5}) == example.end());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
Index: test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
Index: test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
+++ test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
@@ -28,7 +28,7 @@
 #error "This test requires is C++14 (or later)"
 #else
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
Index: test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
+++ test/std/containers/associative/multimap/multimap.special/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -172,4 +172,6 @@
     }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
+++ test/std/containers/associative/multimap/multimap.special/non_member_swap.pass.cpp
@@ -20,7 +20,7 @@
 #include "../../../test_compare.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const int, double> V;
     {
@@ -277,4 +277,6 @@
         assert(m2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
+++ test/std/containers/associative/multimap/multimap.special/swap_noexcept.pass.cpp
@@ -91,7 +91,7 @@
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -137,4 +137,6 @@
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/scary.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/scary.pass.cpp
+++ test/std/containers/associative/multimap/scary.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <map>
 
-int main()
+int main(int, char**)
 {
     typedef std::map<int, int> M1;
     typedef std::multimap<int, int> M2;
     M2::iterator i;
     M1::iterator j = i;
     ((void)j);
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/size.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/size.pass.cpp
+++ test/std/containers/associative/multimap/size.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> M;
@@ -55,4 +55,6 @@
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multimap/types.pass.cpp
===================================================================
--- test/std/containers/associative/multimap/types.pass.cpp
+++ test/std/containers/associative/multimap/types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multimap<int, double> C;
@@ -66,4 +66,6 @@
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/associative/multiset/allocator_mismatch.fail.cpp
+++ test/std/containers/associative/multiset/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <set>
 
-int main()
+int main(int, char**)
 {
     std::multiset<int, std::less<int>, std::allocator<long> > ms;
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/clear.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/clear.pass.cpp
+++ test/std/containers/associative/multiset/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -62,4 +62,6 @@
         assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/count.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/count.pass.cpp
+++ test/std/containers/associative/multiset/count.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -157,4 +157,6 @@
     assert(r == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/count_transparent.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/count_transparent.pass.cpp
+++ test/std/containers/associative/multiset/count_transparent.pass.cpp
@@ -42,9 +42,11 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   std::multiset<std::pair<int, int>, Comp> s{{2, 1}, {1, 1}, {1, 1}, {1, 1}, {2, 2}};
 
   auto cnt = s.count(1);
   assert(cnt == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/emplace.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/emplace.pass.cpp
+++ test/std/containers/associative/multiset/emplace.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<DefaultOnly> M;
@@ -77,4 +77,6 @@
         assert(m.size() == 1);
         assert(*r == 2);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/emplace_hint.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/emplace_hint.pass.cpp
+++ test/std/containers/associative/multiset/emplace_hint.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<DefaultOnly> M;
@@ -77,4 +77,6 @@
         assert(m.size() == 1);
         assert(*r == 2);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/empty.fail.cpp
===================================================================
--- test/std/containers/associative/multiset/empty.fail.cpp
+++ test/std/containers/associative/multiset/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::multiset<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/empty.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/empty.pass.cpp
+++ test/std/containers/associative/multiset/empty.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> M;
@@ -39,4 +39,6 @@
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/equal_range.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/equal_range.pass.cpp
+++ test/std/containers/associative/multiset/equal_range.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -260,4 +260,6 @@
     assert(r.second == next(m.begin(), 9));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
+++ test/std/containers/associative/multiset/equal_range_transparent.pass.cpp
@@ -44,7 +44,7 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   std::multiset<std::pair<int, int>, Comp> s{{2, 1}, {1, 1}, {1, 1}, {1, 1}, {2, 2}};
 
   auto er = s.equal_range(1);
@@ -56,4 +56,6 @@
   }
 
   assert(nels == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/erase_iter.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/erase_iter.pass.cpp
+++ test/std/containers/associative/multiset/erase_iter.pass.cpp
@@ -25,7 +25,7 @@
 
 bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -199,4 +199,6 @@
             c.erase(it);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
+++ test/std/containers/associative/multiset/erase_iter_iter.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -137,4 +137,6 @@
         assert(i == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/erase_key.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/erase_key.pass.cpp
+++ test/std/containers/associative/multiset/erase_key.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -125,4 +125,6 @@
         assert(i == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/extract_iterator.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/extract_iterator.pass.cpp
+++ test/std/containers/associative/multiset/extract_iterator.pass.cpp
@@ -36,7 +36,7 @@
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using set_type = std::multiset<int>;
@@ -56,4 +56,6 @@
         min_alloc_set m = {1, 2, 3, 4, 5, 6};
         test(m);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/extract_key.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/extract_key.pass.cpp
+++ test/std/containers/associative/multiset/extract_key.pass.cpp
@@ -43,7 +43,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::multiset<int> m = {1, 2, 3, 4, 5, 6};
@@ -67,4 +67,6 @@
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/find.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/find.pass.cpp
+++ test/std/containers/associative/multiset/find.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -237,4 +237,6 @@
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/incomplete_type.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/incomplete_type.pass.cpp
+++ test/std/containers/associative/multiset/incomplete_type.pass.cpp
@@ -23,6 +23,8 @@
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/insert_cv.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/insert_cv.pass.cpp
+++ test/std/containers/associative/multiset/insert_cv.pass.cpp
@@ -48,7 +48,7 @@
     assert(*r == 3);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_cv_test<std::multiset<int> >();
 #if TEST_STD_VER >= 11
@@ -57,4 +57,6 @@
         do_insert_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp
+++ test/std/containers/associative/multiset/insert_emplace_allocator_requirements.pass.cpp
@@ -19,8 +19,10 @@
 #include "container_test_types.h"
 #include "../../set_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMultisetInsert<TCT::multiset<> >();
   testMultisetEmplace<TCT::multiset<> >();
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
+++ test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
@@ -56,4 +56,6 @@
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
+++ test/std/containers/associative/multiset/insert_iter_cv.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -69,4 +69,6 @@
         assert(*r == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
+++ test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<int> M;
@@ -81,4 +81,6 @@
         assert(*next(m.begin(), 8) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
+++ test/std/containers/associative/multiset/insert_iter_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> M;
@@ -70,4 +70,6 @@
         assert(m.size() == 4);
         assert(*r == 3);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/insert_node_type.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/insert_node_type.pass.cpp
+++ test/std/containers/associative/multiset/insert_node_type.pass.cpp
@@ -67,10 +67,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::multiset<int> m;
     test(m);
     std::multiset<int, std::less<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp
+++ test/std/containers/associative/multiset/insert_node_type_hint.pass.cpp
@@ -49,10 +49,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::multiset<int> m;
     test(m);
     std::multiset<int, std::less<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/insert_rv.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/insert_rv.pass.cpp
+++ test/std/containers/associative/multiset/insert_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> M;
@@ -70,4 +70,6 @@
         assert(m.size() == 4);
         assert(*r == 3);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/iterator.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/iterator.pass.cpp
+++ test/std/containers/associative/multiset/iterator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -213,4 +213,6 @@
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/lower_bound.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/lower_bound.pass.cpp
+++ test/std/containers/associative/multiset/lower_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -220,4 +220,6 @@
     assert(r == next(m.begin(), 9));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/max_size.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/max_size.pass.cpp
+++ test/std/containers/associative/multiset/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -46,4 +46,6 @@
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/merge.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/merge.pass.cpp
+++ test/std/containers/associative/multiset/merge.pass.cpp
@@ -49,7 +49,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::multiset<int> src{1, 3, 5};
@@ -145,4 +145,5 @@
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/alloc.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::less<int> C;
     typedef test_allocator<int> A;
@@ -25,4 +25,6 @@
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A(5));
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
@@ -51,4 +51,6 @@
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > C;
     const std::multiset<int, C> m(C(3));
@@ -29,4 +29,6 @@
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     assert(m.value_comp() == C(3));
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/compare_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > C;
     typedef test_allocator<int> A;
@@ -27,4 +27,6 @@
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A(5));
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
+++ test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::multiset<int, Comp<int> > m;
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -115,4 +115,6 @@
         assert(*next(mo.begin(), 8) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     V ar[] =
@@ -64,4 +64,6 @@
     assert(*next(mo.begin(), 6) == 3);
     assert(*next(mo.begin(), 7) == 3);
     assert(*next(mo.begin(), 8) == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -134,4 +134,6 @@
         assert(*next(mo.begin(), 7) == 3);
         assert(*next(mo.begin(), 8) == 3);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::multiset<int> m;
@@ -50,4 +50,6 @@
     assert(m.begin() == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/default_noexcept.pass.cpp
@@ -33,7 +33,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -53,4 +53,6 @@
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> C;
@@ -47,4 +47,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
@@ -66,4 +66,6 @@
     assert(*++i == V(6));
     assert(m.get_allocator() == a);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > Cmp;
     typedef std::multiset<int, Cmp> C;
@@ -34,4 +34,6 @@
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > Cmp;
     typedef test_allocator<int> A;
@@ -37,4 +37,6 @@
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
     assert(m.get_allocator() == A(4));
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -79,4 +79,6 @@
     assert(*next(m.begin(), 8) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
@@ -22,7 +22,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -91,4 +91,6 @@
     assert(m.get_allocator() == a);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     V ar[] =
@@ -49,4 +49,6 @@
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -113,4 +113,6 @@
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_allocator.h"
 #include "Counter.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly V;
@@ -184,4 +184,6 @@
         }
         assert(Counter_base::gConstructed == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/move_assign.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly V;
@@ -180,4 +180,6 @@
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/move_assign_noexcept.pass.cpp
@@ -33,7 +33,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> C;
@@ -53,4 +53,6 @@
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
+++ test/std/containers/associative/multiset/multiset.cons/move_noexcept.pass.cpp
@@ -31,7 +31,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -51,4 +51,6 @@
         typedef std::multiset<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp
+++ test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::multiset<int>>();
     test<std::multiset<int, std::less<int>, min_allocator<int>>> ();
@@ -74,4 +74,6 @@
 
     test<std::multiset<long>>();
     test<std::multiset<double>>();
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
+++ test/std/containers/associative/multiset/multiset.special/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -173,4 +173,6 @@
     }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
+++ test/std/containers/associative/multiset/multiset.special/non_member_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     {
@@ -163,4 +163,6 @@
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A(1));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
+++ test/std/containers/associative/multiset/multiset.special/swap_noexcept.pass.cpp
@@ -91,7 +91,7 @@
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::multiset<MoveOnly> C;
@@ -136,4 +136,6 @@
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/scary.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/scary.pass.cpp
+++ test/std/containers/associative/multiset/scary.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <set>
 
-int main()
+int main(int, char**)
 {
     typedef std::set<int> M1;
     typedef std::multiset<int> M2;
     M2::iterator i;
     M1::iterator j = i;
     ((void)j);
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/size.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/size.pass.cpp
+++ test/std/containers/associative/multiset/size.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> M;
@@ -55,4 +55,6 @@
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/types.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/types.pass.cpp
+++ test/std/containers/associative/multiset/types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
@@ -66,4 +66,6 @@
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/multiset/upper_bound.pass.cpp
===================================================================
--- test/std/containers/associative/multiset/upper_bound.pass.cpp
+++ test/std/containers/associative/multiset/upper_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -219,4 +219,6 @@
     assert(r == next(m.begin(), 9));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/associative/set/allocator_mismatch.fail.cpp
+++ test/std/containers/associative/set/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <set>
 
-int main()
+int main(int, char**)
 {
     std::set<int, std::less<int>, std::allocator<long> > s;
+
+  return 0;
 }
Index: test/std/containers/associative/set/clear.pass.cpp
===================================================================
--- test/std/containers/associative/set/clear.pass.cpp
+++ test/std/containers/associative/set/clear.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -62,4 +62,6 @@
         assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/count.pass.cpp
===================================================================
--- test/std/containers/associative/set/count.pass.cpp
+++ test/std/containers/associative/set/count.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -167,4 +167,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/containers/associative/set/count_transparent.pass.cpp
===================================================================
--- test/std/containers/associative/set/count_transparent.pass.cpp
+++ test/std/containers/associative/set/count_transparent.pass.cpp
@@ -42,9 +42,11 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   std::set<std::pair<int, int>, Comp> s{{2, 1}, {1, 2}, {1, 3}, {1, 4}, {2, 2}};
 
   auto cnt = s.count(1);
   assert(cnt == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/set/emplace.pass.cpp
===================================================================
--- test/std/containers/associative/set/emplace.pass.cpp
+++ test/std/containers/associative/set/emplace.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<DefaultOnly> M;
@@ -84,4 +84,6 @@
         assert(m.size() == 1);
         assert(*r.first == 2);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/emplace_hint.pass.cpp
===================================================================
--- test/std/containers/associative/set/emplace_hint.pass.cpp
+++ test/std/containers/associative/set/emplace_hint.pass.cpp
@@ -22,7 +22,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<DefaultOnly> M;
@@ -77,4 +77,6 @@
         assert(m.size() == 1);
         assert(*r == 2);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/empty.fail.cpp
===================================================================
--- test/std/containers/associative/set/empty.fail.cpp
+++ test/std/containers/associative/set/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::set<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/associative/set/empty.pass.cpp
===================================================================
--- test/std/containers/associative/set/empty.pass.cpp
+++ test/std/containers/associative/set/empty.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> M;
@@ -39,4 +39,6 @@
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/equal_range.pass.cpp
===================================================================
--- test/std/containers/associative/set/equal_range.pass.cpp
+++ test/std/containers/associative/set/equal_range.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -367,4 +367,6 @@
     assert(r.second == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/equal_range_transparent.pass.cpp
===================================================================
--- test/std/containers/associative/set/equal_range_transparent.pass.cpp
+++ test/std/containers/associative/set/equal_range_transparent.pass.cpp
@@ -44,7 +44,7 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   std::set<std::pair<int, int>, Comp> s{{2, 1}, {1, 2}, {1, 3}, {1, 4}, {2, 2}};
 
   auto er = s.equal_range(1);
@@ -56,4 +56,6 @@
   }
 
   assert(nels == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/set/erase_iter.pass.cpp
===================================================================
--- test/std/containers/associative/set/erase_iter.pass.cpp
+++ test/std/containers/associative/set/erase_iter.pass.cpp
@@ -25,7 +25,7 @@
 
 bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -199,4 +199,6 @@
             c.erase(it);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/erase_iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/set/erase_iter_iter.pass.cpp
+++ test/std/containers/associative/set/erase_iter_iter.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -137,4 +137,6 @@
         assert(i == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/erase_key.pass.cpp
===================================================================
--- test/std/containers/associative/set/erase_key.pass.cpp
+++ test/std/containers/associative/set/erase_key.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -199,4 +199,6 @@
         assert(i == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/extract_iterator.pass.cpp
===================================================================
--- test/std/containers/associative/set/extract_iterator.pass.cpp
+++ test/std/containers/associative/set/extract_iterator.pass.cpp
@@ -36,7 +36,7 @@
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using set_type = std::set<int>;
@@ -56,4 +56,6 @@
         min_alloc_set m = {1, 2, 3, 4, 5, 6};
         test(m);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/extract_key.pass.cpp
===================================================================
--- test/std/containers/associative/set/extract_key.pass.cpp
+++ test/std/containers/associative/set/extract_key.pass.cpp
@@ -43,7 +43,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::set<int> m = {1, 2, 3, 4, 5, 6};
@@ -67,4 +67,6 @@
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/find.pass.cpp
===================================================================
--- test/std/containers/associative/set/find.pass.cpp
+++ test/std/containers/associative/set/find.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -237,4 +237,6 @@
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/gcc_workaround.pass.cpp
===================================================================
--- test/std/containers/associative/set/gcc_workaround.pass.cpp
+++ test/std/containers/associative/set/gcc_workaround.pass.cpp
@@ -15,7 +15,4 @@
 using std::map;
 using std::multimap;
 
-int main(void)
-{
-       return 0;
-}
+int main(int, char**) { return 0; }
Index: test/std/containers/associative/set/incomplete_type.pass.cpp
===================================================================
--- test/std/containers/associative/set/incomplete_type.pass.cpp
+++ test/std/containers/associative/set/incomplete_type.pass.cpp
@@ -23,6 +23,8 @@
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 inline bool operator<(A const& L, A const& R)  { return L.data < R.data; }
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
Index: test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
===================================================================
--- test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
+++ test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
@@ -20,9 +20,11 @@
 #include "container_test_types.h"
 #include "../../set_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testSetInsert<TCT::set<> >();
   testSetEmplace<TCT::set<> >();
   testSetEmplaceHint<TCT::set<> >();
+
+  return 0;
 }
Index: test/std/containers/associative/set/insert_cv.pass.cpp
===================================================================
--- test/std/containers/associative/set/insert_cv.pass.cpp
+++ test/std/containers/associative/set/insert_cv.pass.cpp
@@ -53,7 +53,7 @@
     assert(*r.first == 3);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_cv_test<std::set<int> >();
 #if TEST_STD_VER >= 11
@@ -62,4 +62,6 @@
         do_insert_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/insert_initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/set/insert_initializer_list.pass.cpp
+++ test/std/containers/associative/set/insert_initializer_list.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> C;
@@ -56,4 +56,6 @@
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/insert_iter_cv.pass.cpp
===================================================================
--- test/std/containers/associative/set/insert_iter_cv.pass.cpp
+++ test/std/containers/associative/set/insert_iter_cv.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -69,4 +69,6 @@
         assert(*r == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/insert_iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/set/insert_iter_iter.pass.cpp
+++ test/std/containers/associative/set/insert_iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<int> M;
@@ -69,4 +69,6 @@
         assert(*next(m.begin(), 2) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/insert_iter_rv.pass.cpp
===================================================================
--- test/std/containers/associative/set/insert_iter_rv.pass.cpp
+++ test/std/containers/associative/set/insert_iter_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> M;
@@ -70,4 +70,6 @@
         assert(m.size() == 3);
         assert(*r == 3);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/insert_node_type.pass.cpp
===================================================================
--- test/std/containers/associative/set/insert_node_type.pass.cpp
+++ test/std/containers/associative/set/insert_node_type.pass.cpp
@@ -73,10 +73,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::set<int> m;
     test(m);
     std::set<int, std::less<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/associative/set/insert_node_type_hint.pass.cpp
===================================================================
--- test/std/containers/associative/set/insert_node_type_hint.pass.cpp
+++ test/std/containers/associative/set/insert_node_type_hint.pass.cpp
@@ -51,10 +51,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::set<int> m;
     test(m);
     std::set<int, std::less<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/associative/set/insert_rv.pass.cpp
===================================================================
--- test/std/containers/associative/set/insert_rv.pass.cpp
+++ test/std/containers/associative/set/insert_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> M;
@@ -78,4 +78,6 @@
         assert(m.size() == 3);
         assert(*r.first == 3);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/iterator.pass.cpp
===================================================================
--- test/std/containers/associative/set/iterator.pass.cpp
+++ test/std/containers/associative/set/iterator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -209,4 +209,6 @@
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/lower_bound.pass.cpp
===================================================================
--- test/std/containers/associative/set/lower_bound.pass.cpp
+++ test/std/containers/associative/set/lower_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -334,4 +334,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/containers/associative/set/max_size.pass.cpp
===================================================================
--- test/std/containers/associative/set/max_size.pass.cpp
+++ test/std/containers/associative/set/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -46,4 +46,6 @@
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/merge.pass.cpp
===================================================================
--- test/std/containers/associative/set/merge.pass.cpp
+++ test/std/containers/associative/set/merge.pass.cpp
@@ -49,7 +49,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::set<int> src{1, 3, 5};
@@ -145,4 +145,5 @@
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
Index: test/std/containers/associative/set/set.cons/alloc.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/alloc.pass.cpp
+++ test/std/containers/associative/set/set.cons/alloc.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::less<int> C;
     typedef test_allocator<int> A;
@@ -25,4 +25,6 @@
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.get_allocator() == A(5));
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
+++ test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> C;
@@ -51,4 +51,6 @@
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/compare.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/compare.pass.cpp
+++ test/std/containers/associative/set/set.cons/compare.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > C;
     const std::set<int, C> m(C(3));
@@ -29,4 +29,6 @@
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
     assert(m.value_comp() == C(3));
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
+++ test/std/containers/associative/set/set.cons/compare_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > C;
     typedef test_allocator<int> A;
@@ -27,4 +27,6 @@
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(4));
     assert(m.get_allocator() == A(5));
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
+++ test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::set<int, Comp<int> > m;
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/copy.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/copy.pass.cpp
+++ test/std/containers/associative/set/set.cons/copy.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -91,4 +91,6 @@
         assert(*next(mo.begin(), 2) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
+++ test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     V ar[] =
@@ -52,4 +52,6 @@
     assert(*mo.begin() == 1);
     assert(*next(mo.begin()) == 2);
     assert(*next(mo.begin(), 2) == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
+++ test/std/containers/associative/set/set.cons/copy_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -105,4 +105,6 @@
         assert(*next(mo.begin()) == 2);
         assert(*next(mo.begin(), 2) == 3);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/default.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/default.pass.cpp
+++ test/std/containers/associative/set/set.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::set<int> m;
@@ -50,4 +50,6 @@
     assert(m.begin() == m.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
+++ test/std/containers/associative/set/set.cons/default_noexcept.pass.cpp
@@ -33,7 +33,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -53,4 +53,6 @@
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/associative/set/set.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> C;
@@ -47,4 +47,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
+++ test/std/containers/associative/set/set.cons/initializer_list.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> C;
@@ -49,4 +49,6 @@
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
+++ test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef test_compare<std::less<int> > Cmp;
     typedef std::set<int, Cmp> C;
@@ -34,4 +34,6 @@
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
+++ test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp
@@ -21,7 +21,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_compare<std::less<int> > Cmp;
@@ -58,4 +58,6 @@
     assert(*++i == V(6));
     assert(m.get_allocator() == A(4));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
+++ test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -67,4 +67,6 @@
     assert(*next(m.begin(), 2) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
+++ test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
@@ -26,7 +26,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -83,4 +83,6 @@
     assert(m.get_allocator() == a);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
+++ test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     V ar[] =
@@ -43,4 +43,6 @@
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/move.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/move.pass.cpp
+++ test/std/containers/associative/set/set.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int V;
@@ -101,4 +101,6 @@
         assert(mo.size() == 0);
         assert(distance(mo.begin(), mo.end()) == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
+++ test/std/containers/associative/set/set.cons/move_alloc.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_allocator.h"
 #include "Counter.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly V;
@@ -185,4 +185,6 @@
         assert(Counter_base::gConstructed == 0);
     }
 
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/move_assign.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/move_assign.pass.cpp
+++ test/std/containers/associative/set/set.cons/move_assign.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly V;
@@ -180,4 +180,6 @@
         assert(m3.key_comp() == C(5));
         assert(m1.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/associative/set/set.cons/move_assign_noexcept.pass.cpp
@@ -33,7 +33,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> C;
@@ -53,4 +53,6 @@
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
+++ test/std/containers/associative/set/set.cons/move_noexcept.pass.cpp
@@ -31,7 +31,7 @@
     bool operator()(const T&, const T&) const { return false; }
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -51,4 +51,6 @@
         typedef std::set<MoveOnly, some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.erasure/erase_if.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.erasure/erase_if.pass.cpp
+++ test/std/containers/associative/set/set.erasure/erase_if.pass.cpp
@@ -55,7 +55,7 @@
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::set<int>>();
     test<std::set<int, std::less<int>, min_allocator<int>>> ();
@@ -63,4 +63,6 @@
 
     test<std::set<long>>();
     test<std::set<double>>();
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.special/member_swap.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.special/member_swap.pass.cpp
+++ test/std/containers/associative/set/set.special/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -173,4 +173,6 @@
     }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
+++ test/std/containers/associative/set/set.special/non_member_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "../../../test_compare.h"
 
-int main()
+int main(int, char**)
 {
     typedef int V;
     {
@@ -163,4 +163,6 @@
         assert(m2.key_comp() == C(1));
         assert(m2.get_allocator() == A(1));
     }
+
+  return 0;
 }
Index: test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
+++ test/std/containers/associative/set/set.special/swap_noexcept.pass.cpp
@@ -91,7 +91,7 @@
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::set<MoveOnly> C;
@@ -137,4 +137,6 @@
 #endif // _LIBCPP_VERSION
 #endif
 
+
+  return 0;
 }
Index: test/std/containers/associative/set/size.pass.cpp
===================================================================
--- test/std/containers/associative/set/size.pass.cpp
+++ test/std/containers/associative/set/size.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> M;
@@ -55,4 +55,6 @@
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/types.pass.cpp
===================================================================
--- test/std/containers/associative/set/types.pass.cpp
+++ test/std/containers/associative/set/types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::set<int> C;
@@ -66,4 +66,6 @@
     static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/associative/set/upper_bound.pass.cpp
===================================================================
--- test/std/containers/associative/set/upper_bound.pass.cpp
+++ test/std/containers/associative/set/upper_bound.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "private_constructor.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int V;
@@ -333,4 +333,6 @@
     assert(r == next(m.begin(), 8));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/nothing_to_do.pass.cpp
+++ test/std/containers/container.adaptors/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_alloc.pass.cpp
@@ -40,9 +40,11 @@
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     test<int> q((test_allocator<int>(3)));
     assert(q.c.get_allocator() == test_allocator<int>(3));
     assert(q.c.size() == 0);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_alloc.pass.cpp
@@ -40,9 +40,11 @@
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     test<int> q(std::less<int>(), test_allocator<int>(3));
     assert(q.c.get_allocator() == test_allocator<int>(3));
     assert(q.c.size() == 0);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_cont_alloc.pass.cpp
@@ -51,7 +51,7 @@
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::vector<int, test_allocator<int> > C;
     C v = make<C>(5);
@@ -59,4 +59,6 @@
     assert(q.c.get_allocator() == test_allocator<int>(3));
     assert(q.size() == 5);
     assert(q.top() == 4);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_comp_rcont_alloc.pass.cpp
@@ -51,11 +51,13 @@
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::vector<int, test_allocator<int> > C;
     test<int> q(std::less<int>(), make<C>(5), test_allocator<int>(3));
     assert(q.c.get_allocator() == test_allocator<int>(3));
     assert(q.size() == 5);
     assert(q.top() == 4);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_copy_alloc.pass.cpp
@@ -45,7 +45,7 @@
     using base::c;
 };
 
-int main()
+int main(int, char**)
 {
     test<int> qo(std::less<int>(),
                       make<std::vector<int, test_allocator<int> > >(5),
@@ -54,4 +54,6 @@
     assert(q.size() == 5);
     assert(q.c.get_allocator() == test_allocator<int>(6));
     assert(q.top() == int(4));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons.alloc/ctor_move_alloc.pass.cpp
@@ -53,7 +53,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> qo(std::less<MoveOnly>(),
                       make<std::vector<MoveOnly, test_allocator<MoveOnly> > >(5),
@@ -62,4 +62,6 @@
     assert(q.size() == 5);
     assert(q.c.get_allocator() == test_allocator<MoveOnly>(6));
     assert(q.top() == MoveOnly(4));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_copy.pass.cpp
@@ -24,7 +24,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v = make<std::vector<int> >(5);
     std::priority_queue<int, std::vector<int>, std::greater<int> > qo(std::greater<int>(), v);
@@ -32,4 +32,6 @@
     q = qo;
     assert(q.size() == 5);
     assert(q.top() == 0);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/assign_move.pass.cpp
@@ -29,11 +29,13 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<MoveOnly> qo(std::less<MoveOnly>(), make<std::vector<MoveOnly> >(5));
     std::priority_queue<MoveOnly> q;
     q = std::move(qo);
     assert(q.size() == 5);
     assert(q.top() == MoveOnly(4));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int, std::vector<int, limited_allocator<int, 10> > > q((std::less<int>()));
     assert(q.size() == 0);
@@ -23,4 +23,6 @@
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp
@@ -24,10 +24,12 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v = make<std::vector<int> >(5);
     std::priority_queue<int, std::vector<int>, std::greater<int> > q(std::greater<int>(), v);
     assert(q.size() == 5);
     assert(q.top() == 0);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp
@@ -29,9 +29,11 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<MoveOnly> q(std::less<MoveOnly>(), make<std::vector<MoveOnly> >(5));
     assert(q.size() == 5);
     assert(q.top() == MoveOnly(4));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_copy.pass.cpp
@@ -24,11 +24,13 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v = make<std::vector<int> >(5);
     std::priority_queue<int, std::vector<int>, std::greater<int> > qo(std::greater<int>(), v);
     std::priority_queue<int, std::vector<int>, std::greater<int> > q = qo;
     assert(q.size() == 5);
     assert(q.top() == 0);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int, std::vector<int, limited_allocator<int, 10> > > q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter.pass.cpp
@@ -15,11 +15,13 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     int* an = a + sizeof(a)/sizeof(a[0]);
     std::priority_queue<int> q(a, an);
     assert(q.size() == static_cast<std::size_t>(an - a));
     assert(q.top() == 8);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp
@@ -16,7 +16,7 @@
 #include <functional>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     int* an = a + sizeof(a)/sizeof(a[0]);
@@ -24,4 +24,6 @@
         q(a, an, std::greater<int>());
     assert(q.size() == static_cast<std::size_t>(an - a));
     assert(q.top() == 0);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_cont.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     const int n = sizeof(a)/sizeof(a[0]);
@@ -23,4 +23,6 @@
     std::priority_queue<int> q(a+n/2, a+n, std::less<int>(), v);
     assert(q.size() == n);
     assert(q.top() == 8);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp_rcont.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     const int n = sizeof(a)/sizeof(a[0]);
@@ -28,4 +28,6 @@
                                     std::vector<MoveOnly>(a, a+n/2));
     assert(q.size() == n);
     assert(q.top() == MoveOnly(8));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_move.pass.cpp
@@ -29,10 +29,12 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<MoveOnly> qo(std::less<MoveOnly>(), make<std::vector<MoveOnly> >(5));
     std::priority_queue<MoveOnly> q = std::move(qo);
     assert(q.size() == 5);
     assert(q.top() == MoveOnly(4));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp
@@ -17,7 +17,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -54,4 +54,6 @@
 //      stack<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp
@@ -38,7 +38,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -119,4 +119,6 @@
     assert(pri.size() == 4);
     assert(pri.top() == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/default_noexcept.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -31,4 +31,6 @@
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/dtor_noexcept.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_assign_noexcept.pass.cpp
@@ -21,10 +21,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.cons/move_noexcept.pass.cpp
@@ -21,10 +21,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.members/emplace.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "../../../Emplaceable.h"
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<Emplaceable> q;
     q.emplace(1, 2.5);
@@ -28,4 +28,6 @@
     assert(q.top() == Emplaceable(3, 4.5));
     q.emplace(2, 3.5);
     assert(q.top() == Emplaceable(3, 4.5));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::priority_queue<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     assert(q.empty());
@@ -23,4 +23,6 @@
     assert(!q.empty());
     q.pop();
     assert(q.empty());
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.members/pop.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     q.push(1);
@@ -30,4 +30,6 @@
     assert(q.top() == 1);
     q.pop();
     assert(q.empty());
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.members/push.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     q.push(1);
@@ -24,4 +24,6 @@
     assert(q.top() == 3);
     q.push(2);
     assert(q.top() == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.members/push_rvalue.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<MoveOnly> q;
     q.push(1);
@@ -28,4 +28,6 @@
     assert(q.top() == 3);
     q.push(2);
     assert(q.top() == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.members/size.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@
     assert(q.size() == 1);
     q.pop();
     assert(q.size() == 0);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.members/swap.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q1;
     std::priority_queue<int> q2;
@@ -26,4 +26,6 @@
     assert(q1.empty());
     assert(q2.size() == 3);
     assert(q2.top() == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.members/top.pass.cpp
@@ -15,7 +15,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q;
     q.push(1);
@@ -24,4 +24,6 @@
     assert(q.top() == 3);
     q.push(2);
     assert(q.top() == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.special/swap.pass.cpp
@@ -17,7 +17,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::priority_queue<int> q1;
     std::priority_queue<int> q2;
@@ -28,4 +28,6 @@
     assert(q1.empty());
     assert(q2.size() == 3);
     assert(q2.top() == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/priqueue.special/swap_noexcept.pass.cpp
@@ -22,10 +22,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::priority_queue<MoveOnly> C;
         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/types.fail.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/types.fail.cpp
+++ test/std/containers/container.adaptors/priority.queue/types.fail.cpp
@@ -27,8 +27,10 @@
 #include <cassert>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 //  LWG#2566 says that the first template param must match the second one's value type
     std::priority_queue<double, std::deque<int>> t;
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/priority.queue/types.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/priority.queue/types.pass.cpp
+++ test/std/containers/container.adaptors/priority.queue/types.pass.cpp
@@ -50,7 +50,7 @@
     typedef int size_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_same<std::priority_queue<int>::container_type, std::vector<int> >::value), "");
     static_assert(( std::is_same<std::priority_queue<int, std::deque<int> >::container_type, std::deque<int> >::value), "");
@@ -64,4 +64,6 @@
     static_assert(( std::uses_allocator<std::priority_queue<int>, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<std::priority_queue<int, C>, std::allocator<int> >::value), "");
     test t;
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_alloc.pass.cpp
@@ -31,8 +31,10 @@
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     test q(test_allocator<int>(3));
     assert(q.get_allocator() == test_allocator<int>(3));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_container_alloc.pass.cpp
@@ -44,7 +44,7 @@
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     C d = make<C>(5);
     test q(d, test_allocator<int>(4));
@@ -55,4 +55,6 @@
         assert(q.front() == d[i]);
         q.pop();
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_queue_alloc.pass.cpp
@@ -42,10 +42,12 @@
     allocator_type get_allocator() {return this->c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     test<int> q(make<C>(5), test_allocator<int>(4));
     test<int> q2(q, test_allocator<int>(5));
     assert(q2.get_allocator() == test_allocator<int>(5));
     assert(q2.size() == 5);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rcontainer_alloc.pass.cpp
@@ -48,9 +48,11 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> q(make<C>(5), test_allocator<MoveOnly>(4));
     assert(q.get_allocator() == test_allocator<MoveOnly>(4));
     assert(q.size() == 5);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons.alloc/ctor_rqueue_alloc.pass.cpp
@@ -48,10 +48,12 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> q(make<C>(5), test_allocator<MoveOnly>(4));
     test<MoveOnly> q2(std::move(q), test_allocator<MoveOnly>(5));
     assert(q2.get_allocator() == test_allocator<MoveOnly>(5));
     assert(q2.size() == 5);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp
@@ -24,7 +24,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> d = make<std::deque<int> >(5);
     std::queue<int> q(d);
@@ -34,4 +34,6 @@
         assert(q.front() == d[i]);
         q.pop();
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/ctor_copy.pass.cpp
@@ -23,9 +23,11 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q(make<std::deque<int> >(5));
     std::queue<int> q2 = q;
     assert(q2 == q);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::queue<int, std::vector<int, limited_allocator<int, 10> > > q;
     assert(q.size() == 0);
@@ -24,4 +24,6 @@
     assert(q.size() == 2);
     assert(q.front() == 1);
     assert(q.back() == 2);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/ctor_move.pass.cpp
@@ -29,10 +29,12 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::queue<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     std::queue<MoveOnly> q2 = std::move(q);
     assert(q2.size() == 5);
     assert(q.empty());
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp
@@ -29,8 +29,10 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::queue<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     assert(q.size() == 5);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/deduct.fail.cpp
@@ -17,7 +17,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -42,4 +42,6 @@
 //      stack<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/deduct.pass.cpp
@@ -33,7 +33,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -87,4 +87,6 @@
     assert(que.back() == 3);
     }
 
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/default_noexcept.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -29,4 +29,6 @@
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/dtor_noexcept.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::queue<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/move_assign_noexcept.pass.cpp
@@ -20,10 +20,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::queue<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.cons/move_noexcept.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -30,4 +30,6 @@
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/assign_copy.pass.cpp
@@ -23,10 +23,12 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q(make<std::deque<int> >(5));
     std::queue<int> q2;
     q2 = q;
     assert(q2 == q);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/assign_move.pass.cpp
@@ -29,11 +29,13 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::queue<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     std::queue<MoveOnly> q2;
     q2 = std::move(q);
     assert(q2.size() == 5);
     assert(q.empty());
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/back.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -22,4 +22,6 @@
     q.push(3);
     int& ir = q.back();
     assert(ir == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/back_const.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@
     const std::queue<int>& cqr = q;
     const int& cir = cqr.back();
     assert(cir == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/emplace.pass.cpp
@@ -37,7 +37,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<std::queue<int> > ();
     test_return_type<std::queue<int, std::list<int> > > ();
@@ -61,4 +61,6 @@
     assert(q.size() == 3);
     assert(q.front() == Emplaceable(1, 2.5));
     assert(q.back() == Emplaceable(3, 4.5));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::queue<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/empty.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.empty());
@@ -21,4 +21,6 @@
     assert(!q.empty());
     q.pop();
     assert(q.empty());
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/front.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -22,4 +22,6 @@
     q.push(3);
     int& ir = q.front();
     assert(ir == 1);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/front_const.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@
     const std::queue<int>& cqr = q;
     const int& cir = cqr.front();
     assert(cir == 1);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/pop.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
@@ -33,4 +33,6 @@
     assert(q.back() == 3);
     q.pop();
     assert(q.size() == 0);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/push.pass.cpp
@@ -13,7 +13,7 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     q.push(1);
@@ -28,4 +28,6 @@
     assert(q.size() == 3);
     assert(q.front() == 1);
     assert(q.back() == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/push_rv.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     std::queue<MoveOnly> q;
     q.push(MoveOnly(1));
@@ -32,4 +32,6 @@
     assert(q.size() == 3);
     assert(q.front() == MoveOnly(1));
     assert(q.back() == MoveOnly(3));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/size.pass.cpp
@@ -13,10 +13,12 @@
 #include <queue>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q;
     assert(q.size() == 0);
     q.push(1);
     assert(q.size() == 1);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/swap.pass.cpp
@@ -23,7 +23,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q1 = make<std::queue<int> >(5);
     std::queue<int> q2 = make<std::queue<int> >(10);
@@ -32,4 +32,6 @@
     q1.swap(q2);
     assert(q1 == q2_save);
     assert(q2 == q1_save);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
@@ -12,8 +12,10 @@
 #include <cassert>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 //  LWG#2566 says that the first template param must match the second one's value type
     std::queue<double, std::deque<int>> t;
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.defn/types.pass.cpp
@@ -43,7 +43,7 @@
     typedef int size_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_same<std::queue<int>::container_type, std::deque<int> >::value), "");
     static_assert(( std::is_same<std::queue<int, std::vector<int> >::container_type, std::vector<int> >::value), "");
@@ -54,4 +54,6 @@
     static_assert(( std::uses_allocator<std::queue<int>, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<std::queue<int, C>, std::allocator<int> >::value), "");
     test t;
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.ops/eq.pass.cpp
@@ -27,7 +27,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q1 = make<std::queue<int> >(5);
     std::queue<int> q2 = make<std::queue<int> >(10);
@@ -36,4 +36,6 @@
     assert(q1 == q1_save);
     assert(q1 != q2);
     assert(q2 == q2_save);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.ops/lt.pass.cpp
@@ -33,7 +33,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q1 = make<std::queue<int> >(5);
     std::queue<int> q2 = make<std::queue<int> >(10);
@@ -41,4 +41,6 @@
     assert(q2 > q1);
     assert(q1 <= q2);
     assert(q2 >= q1);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.special/swap.pass.cpp
@@ -24,7 +24,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::queue<int> q1 = make<std::queue<int> >(5);
     std::queue<int> q2 = make<std::queue<int> >(10);
@@ -33,4 +33,6 @@
     swap(q1, q2);
     assert(q1 == q2_save);
     assert(q2 == q1_save);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/queue/queue.special/swap_noexcept.pass.cpp
@@ -21,10 +21,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::queue<MoveOnly> C;
         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_alloc.pass.cpp
@@ -31,8 +31,10 @@
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     test q(test_allocator<int>(3));
     assert(q.get_allocator() == test_allocator<int>(3));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_container_alloc.pass.cpp
@@ -44,7 +44,7 @@
     test_allocator<int> get_allocator() {return c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     C d = make<C>(5);
     test q(d, test_allocator<int>(4));
@@ -55,4 +55,6 @@
         assert(q.top() == d[d.size() - i - 1]);
         q.pop();
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_copy_alloc.pass.cpp
@@ -42,10 +42,12 @@
     allocator_type get_allocator() {return this->c.get_allocator();}
 };
 
-int main()
+int main(int, char**)
 {
     test<int> q(make<C>(5), test_allocator<int>(4));
     test<int> q2(q, test_allocator<int>(5));
     assert(q2.get_allocator() == test_allocator<int>(5));
     assert(q2.size() == 5);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rcontainer_alloc.pass.cpp
@@ -48,9 +48,11 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> q(make<C>(5), test_allocator<MoveOnly>(4));
     assert(q.get_allocator() == test_allocator<MoveOnly>(4));
     assert(q.size() == 5);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons.alloc/ctor_rqueue_alloc.pass.cpp
@@ -48,10 +48,12 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     test<MoveOnly> q(make<C>(5), test_allocator<MoveOnly>(4));
     test<MoveOnly> q2(std::move(q), test_allocator<MoveOnly>(5));
     assert(q2.get_allocator() == test_allocator<MoveOnly>(5));
     assert(q2.size() == 5);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp
@@ -24,7 +24,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> d = make<std::deque<int> >(5);
     std::stack<int> q(d);
@@ -34,4 +34,6 @@
         assert(q.top() == d[d.size() - i - 1]);
         q.pop();
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/ctor_copy.pass.cpp
@@ -23,9 +23,11 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q(make<std::deque<int> >(5));
     std::stack<int> q2 = q;
     assert(q2 == q);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::stack<int, std::vector<int, limited_allocator<int, 10> > > q;
     assert(q.size() == 0);
@@ -24,4 +24,6 @@
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/ctor_move.pass.cpp
@@ -29,10 +29,12 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::stack<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     std::stack<MoveOnly> q2 = std::move(q);
     assert(q2.size() == 5);
     assert(q.empty());
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp
@@ -29,8 +29,10 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::stack<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     assert(q.size() == 5);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/deduct.fail.cpp
@@ -24,7 +24,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -49,4 +49,6 @@
 //      stack<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/deduct.pass.cpp
@@ -35,7 +35,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -90,4 +90,6 @@
     assert(stk.top() == 3);
     }
 
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/default_noexcept.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -30,4 +30,6 @@
         static_assert(std::is_nothrow_default_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/dtor_noexcept.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::stack<MoveOnly> C;
         static_assert(std::is_nothrow_destructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/move_assign_noexcept.pass.cpp
@@ -20,10 +20,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::stack<MoveOnly> C;
         static_assert(std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.cons/move_noexcept.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -29,4 +29,6 @@
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/assign_copy.pass.cpp
@@ -23,10 +23,12 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q(make<std::deque<int> >(5));
     std::stack<int> q2;
     q2 = q;
     assert(q2 == q);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/assign_move.pass.cpp
@@ -29,11 +29,13 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::stack<MoveOnly> q(make<std::deque<MoveOnly> >(5));
     std::stack<MoveOnly> q2;
     q2 = std::move(q);
     assert(q2.size() == 5);
     assert(q.empty());
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/emplace.pass.cpp
@@ -36,7 +36,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<std::stack<int> > ();
     test_return_type<std::stack<int, std::vector<int> > > ();
@@ -57,4 +57,6 @@
 #endif
     assert(q.size() == 3);
     assert(q.top() == Emplaceable(3, 4.5));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::stack<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/empty.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.empty());
@@ -21,4 +21,6 @@
     assert(!q.empty());
     q.pop();
     assert(q.empty());
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/pop.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.size() == 0);
@@ -30,4 +30,6 @@
     assert(q.top() == 1);
     q.pop();
     assert(q.size() == 0);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/push.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     q.push(1);
@@ -25,4 +25,6 @@
     q.push(3);
     assert(q.size() == 3);
     assert(q.top() == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/push_rv.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     std::stack<MoveOnly> q;
     q.push(MoveOnly(1));
@@ -29,4 +29,6 @@
     q.push(MoveOnly(3));
     assert(q.size() == 3);
     assert(q.top() == MoveOnly(3));
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/size.pass.cpp
@@ -13,10 +13,12 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.size() == 0);
     q.push(1);
     assert(q.size() == 1);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/swap.pass.cpp
@@ -23,7 +23,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q1 = make<std::stack<int> >(5);
     std::stack<int> q2 = make<std::stack<int> >(10);
@@ -32,4 +32,6 @@
     q1.swap(q2);
     assert(q1 == q2_save);
     assert(q2 == q1_save);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/top.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.size() == 0);
@@ -22,4 +22,6 @@
     q.push(3);
     int& ir = q.top();
     assert(ir == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/top_const.pass.cpp
@@ -13,7 +13,7 @@
 #include <stack>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q;
     assert(q.size() == 0);
@@ -23,4 +23,6 @@
     const std::stack<int>& cqr = q;
     const int& cir = cqr.top();
     assert(cir == 3);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
@@ -27,8 +27,10 @@
 #include <cassert>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 //  LWG#2566 says that the first template param must match the second one's value type
     std::stack<double, std::deque<int>> t;
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.defn/types.pass.cpp
@@ -44,7 +44,7 @@
     typedef int size_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_same<std::stack<int>::container_type, std::deque<int> >::value), "");
     static_assert(( std::is_same<std::stack<int, std::vector<int> >::container_type, std::vector<int> >::value), "");
@@ -55,4 +55,6 @@
     static_assert(( std::uses_allocator<std::stack<int>, std::allocator<int> >::value), "");
     static_assert((!std::uses_allocator<std::stack<int, C>, std::allocator<int> >::value), "");
     test t;
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.ops/eq.pass.cpp
@@ -27,7 +27,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q1 = make<std::stack<int> >(5);
     std::stack<int> q2 = make<std::stack<int> >(10);
@@ -36,4 +36,6 @@
     assert(q1 == q1_save);
     assert(q1 != q2);
     assert(q2 == q2_save);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.ops/lt.pass.cpp
@@ -33,7 +33,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q1 = make<std::stack<int> >(5);
     std::stack<int> q2 = make<std::stack<int> >(10);
@@ -41,4 +41,6 @@
     assert(q2 > q1);
     assert(q1 <= q2);
     assert(q2 >= q1);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.special/swap.pass.cpp
@@ -24,7 +24,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     std::stack<int> q1 = make<std::stack<int> >(5);
     std::stack<int> q2 = make<std::stack<int> >(10);
@@ -33,4 +33,6 @@
     swap(q1, q2);
     assert(q1 == q2_save);
     assert(q2 == q1_save);
+
+  return 0;
 }
Index: test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
+++ test/std/containers/container.adaptors/stack/stack.special/swap_noexcept.pass.cpp
@@ -21,10 +21,12 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::stack<MoveOnly> C;
         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
+
+  return 0;
 }
Index: test/std/containers/container.node/node_handle.pass.cpp
===================================================================
--- test/std/containers/container.node/node_handle.pass.cpp
+++ test/std/containers/container.node/node_handle.pass.cpp
@@ -128,7 +128,7 @@
     test_typedef<typename Container::insert_return_type>();
 }
 
-int main()
+int main(int, char**)
 {
     test_node_handle_operations<std::map<int, int>>();
     test_node_handle_operations_multi<std::multimap<int, int>>();
@@ -143,4 +143,6 @@
     test_insert_return_type<std::set<int>>();
     test_insert_return_type<std::unordered_map<int, int>>();
     test_insert_return_type<std::unordered_set<int>>();
+
+  return 0;
 }
Index: test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp
+++ test/std/containers/container.requirements/associative.reqmts/associative.reqmts.except/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp
+++ test/std/containers/container.requirements/associative.reqmts/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp
+++ test/std/containers/container.requirements/container.requirements.dataraces/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp
===================================================================
--- test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp
+++ test/std/containers/container.requirements/container.requirements.general/allocator_move.pass.cpp
@@ -61,7 +61,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   { // test sequence containers
     test<std::vector<int, test_allocator<int> > >();
     test<std::vector<bool, test_allocator<bool> > >();
@@ -102,4 +102,6 @@
     test<std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>,
                                  test_allocator<KV> > >(stored_allocators);
   }
+
+  return 0;
 }
Index: test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp
+++ test/std/containers/container.requirements/container.requirements.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/container.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/container.requirements/nothing_to_do.pass.cpp
+++ test/std/containers/container.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp
+++ test/std/containers/container.requirements/sequence.reqmts/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp
+++ test/std/containers/container.requirements/unord.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp
+++ test/std/containers/container.requirements/unord.req/unord.req.except/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/containers.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/containers.general/nothing_to_do.pass.cpp
+++ test/std/containers/containers.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/nothing_to_do.pass.cpp
+++ test/std/containers/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.cons/deduct.fail.cpp
===================================================================
--- test/std/containers/sequences/array/array.cons/deduct.fail.cpp
+++ test/std/containers/sequences/array/array.cons/deduct.fail.cpp
@@ -28,9 +28,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::array arr{1,2,3L}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'array'}}
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.cons/deduct.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.cons/deduct.pass.cpp
+++ test/std/containers/sequences/array/array.cons/deduct.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -61,4 +61,6 @@
     assert(arr[0] == 4.0);
     assert(arr[1] == 5.0);
   }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.cons/default.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.cons/default.pass.cpp
+++ test/std/containers/sequences/array/array.cons/default.pass.cpp
@@ -21,7 +21,7 @@
   NoDefault(int) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -44,4 +44,6 @@
       C c2 = {{}};
       assert(c2.size() == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
+++ test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp
@@ -32,7 +32,7 @@
   NoDefault(int) {}
 };
 
-int main() {
+int main(int, char**) {
   {
     typedef double T;
     typedef std::array<T, 3> C;
@@ -89,4 +89,6 @@
     TEST_NOT_COPY_ASSIGNABLE(C);
   }
 
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
+++ test/std/containers/sequences/array/array.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         C c = {};
         assert(c.size() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.data/data.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.data/data.pass.cpp
+++ test/std/containers/sequences/array/array.data/data.pass.cpp
@@ -25,7 +25,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -67,4 +67,6 @@
       T* p = c.data();
       LIBCPP_ASSERT(p != nullptr);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.data/data_const.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.data/data_const.pass.cpp
+++ test/std/containers/sequences/array/array.data/data_const.pass.cpp
@@ -24,7 +24,7 @@
   NoDefault(int) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -70,4 +70,6 @@
         static_assert ( *c2.data()  ==  c2[0], "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.fill/fill.fail.cpp
===================================================================
--- test/std/containers/sequences/array/array.fill/fill.fail.cpp
+++ test/std/containers/sequences/array/array.fill/fill.fail.cpp
@@ -17,7 +17,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main() {
+int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
@@ -25,4 +25,6 @@
     // expected-error-re@array:* {{static_assert failed {{.*}}"cannot fill zero-sized array of type 'const T'"}}
     c.fill(5.5); // expected-note {{requested here}}
   }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.fill/fill.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.fill/fill.pass.cpp
+++ test/std/containers/sequences/array/array.fill/fill.pass.cpp
@@ -17,7 +17,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -36,4 +36,6 @@
         c.fill(5.5);
         assert(c.size() == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.size/size.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.size/size.pass.cpp
+++ test/std/containers/sequences/array/array.size/size.pass.cpp
@@ -19,7 +19,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -55,4 +55,6 @@
         static_assert(c.empty(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.special/swap.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.special/swap.pass.cpp
+++ test/std/containers/sequences/array/array.special/swap.pass.cpp
@@ -35,7 +35,7 @@
 template <class Tp>
 struct can_swap : std::is_same<decltype(can_swap_imp<Tp>(0)), void> {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -81,4 +81,6 @@
         static_assert(!can_swap<C1&>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.swap/swap.fail.cpp
===================================================================
--- test/std/containers/sequences/array/array.swap/swap.fail.cpp
+++ test/std/containers/sequences/array/array.swap/swap.fail.cpp
@@ -17,7 +17,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main() {
+int main(int, char**) {
   {
     typedef double T;
     typedef std::array<const T, 0> C;
@@ -26,4 +26,6 @@
     // expected-error-re@array:* {{static_assert failed {{.*}}"cannot swap zero-sized array of type 'const T'"}}
     c.swap(c2); // expected-note {{requested here}}
   }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.swap/swap.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.swap/swap.pass.cpp
+++ test/std/containers/sequences/array/array.swap/swap.pass.cpp
@@ -27,7 +27,7 @@
   NonSwappable& operator=(NonSwappable const&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -89,4 +89,6 @@
 #endif
     }
 
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.tuple/get.fail.cpp
===================================================================
--- test/std/containers/sequences/array/array.tuple/get.fail.cpp
+++ test/std/containers/sequences/array/array.tuple/get.fail.cpp
@@ -23,7 +23,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -32,4 +32,6 @@
         std::get<3>(c) = 5.5; // expected-note {{requested here}}
         // expected-error-re@array:* {{static_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}} "Index out of bounds in std::get<> (std::array)"}}
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.tuple/get.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.tuple/get.pass.cpp
+++ test/std/containers/sequences/array/array.tuple/get.pass.cpp
@@ -30,7 +30,7 @@
 constexpr std::array<int, 2> getArr () { return { 3, 4 }; }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -55,4 +55,6 @@
         static_assert(std::get<1>(getArr()) == 4, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.tuple/get_const.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.tuple/get_const.pass.cpp
+++ test/std/containers/sequences/array/array.tuple/get_const.pass.cpp
@@ -19,7 +19,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -39,4 +39,6 @@
         static_assert(std::get<2>(c) == 3.5, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp
+++ test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp
@@ -24,7 +24,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -47,4 +47,6 @@
     static_assert(std::get<2>(std::move(c)) == 3.5, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp
+++ test/std/containers/sequences/array/array.tuple/get_rv.pass.cpp
@@ -21,7 +21,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -31,4 +31,6 @@
         T t = std::get<0>(std::move(c));
         assert(*t == 3.5);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp
===================================================================
--- test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp
+++ test/std/containers/sequences/array/array.tuple/tuple_element.fail.cpp
@@ -23,7 +23,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -31,4 +31,6 @@
         std::tuple_element<3, C> foo; // expected-note {{requested here}}
         // expected-error-re@array:* {{static_assert failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}} "Index out of bounds in std::tuple_element<> (std::array)"}}
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp
+++ test/std/containers/sequences/array/array.tuple/tuple_element.pass.cpp
@@ -46,8 +46,10 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<double>();
     test<int>();
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp
+++ test/std/containers/sequences/array/array.tuple/tuple_size.pass.cpp
@@ -33,9 +33,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<double, 0>();
     test<double, 3>();
     test<double, 5>();
+
+  return 0;
 }
Index: test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp
===================================================================
--- test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp
+++ test/std/containers/sequences/array/array.zero/tested_elsewhere.pass.cpp
@@ -12,6 +12,8 @@
 
 #include <array>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/sequences/array/at.pass.cpp
===================================================================
--- test/std/containers/sequences/array/at.pass.cpp
+++ test/std/containers/sequences/array/at.pass.cpp
@@ -30,7 +30,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -116,4 +116,6 @@
         static_assert (check_idx(2, 3.5), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/begin.pass.cpp
===================================================================
--- test/std/containers/sequences/array/begin.pass.cpp
+++ test/std/containers/sequences/array/begin.pass.cpp
@@ -24,7 +24,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
       LIBCPP_ASSERT(ib != nullptr);
       LIBCPP_ASSERT(ie != nullptr);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/compare.fail.cpp
===================================================================
--- test/std/containers/sequences/array/compare.fail.cpp
+++ test/std/containers/sequences/array/compare.fail.cpp
@@ -41,7 +41,7 @@
 
 template <int Dummy> struct NoCompare {};
 
-int main()
+int main(int, char**)
 {
   {
     typedef NoCompare<0> T;
@@ -67,4 +67,6 @@
     TEST_IGNORE_NODISCARD (c1 == c1);
     TEST_IGNORE_NODISCARD (c1 < c1);
   }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/compare.pass.cpp
===================================================================
--- test/std/containers/sequences/array/compare.pass.cpp
+++ test/std/containers/sequences/array/compare.pass.cpp
@@ -28,7 +28,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
   {
     typedef int T;
@@ -58,4 +58,6 @@
   static_assert(testComparisons6(a2, a1, false, false), "");
   }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/contiguous.pass.cpp
===================================================================
--- test/std/containers/sequences/array/contiguous.pass.cpp
+++ test/std/containers/sequences/array/contiguous.pass.cpp
@@ -20,11 +20,13 @@
         assert ( *(c.begin() + i) == *(std::addressof(*c.begin()) + i));
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
         typedef std::array<T, 3> C;
         test_contiguous (C());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/empty.fail.cpp
===================================================================
--- test/std/containers/sequences/array/empty.fail.cpp
+++ test/std/containers/sequences/array/empty.fail.cpp
@@ -20,11 +20,13 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
 
     std::array<int, 1> c;
     c.empty(); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::array<int, 0> c0;
     c0.empty(); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/sequences/array/empty.pass.cpp
===================================================================
--- test/std/containers/sequences/array/empty.pass.cpp
+++ test/std/containers/sequences/array/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::array<int, 2> C;
@@ -32,4 +32,6 @@
     ASSERT_NOEXCEPT(c.empty());
     assert( c.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/front_back.pass.cpp
===================================================================
--- test/std/containers/sequences/array/front_back.pass.cpp
+++ test/std/containers/sequences/array/front_back.pass.cpp
@@ -36,7 +36,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -115,4 +115,6 @@
         static_assert (check_back (3.5), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/indexing.pass.cpp
===================================================================
--- test/std/containers/sequences/array/indexing.pass.cpp
+++ test/std/containers/sequences/array/indexing.pass.cpp
@@ -30,7 +30,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -104,4 +104,6 @@
         static_assert (check_idx(2, 3.5), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/iterators.pass.cpp
===================================================================
--- test/std/containers/sequences/array/iterators.pass.cpp
+++ test/std/containers/sequences/array/iterators.pass.cpp
@@ -20,7 +20,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::array<int, 5> C;
@@ -141,4 +141,6 @@
         static_assert ( *std::crbegin(c) == 4, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/array/max_size.pass.cpp
===================================================================
--- test/std/containers/sequences/array/max_size.pass.cpp
+++ test/std/containers/sequences/array/max_size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::array<int, 2> C;
@@ -32,4 +32,6 @@
     ASSERT_NOEXCEPT(c.max_size());
     assert(c.max_size() == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/array/size_and_alignment.pass.cpp
===================================================================
--- test/std/containers/sequences/array/size_and_alignment.pass.cpp
+++ test/std/containers/sequences/array/size_and_alignment.pass.cpp
@@ -57,7 +57,9 @@
   char data[1000];
 };
 
-int main() {
+//static_assert(sizeof(void*) == 4, "");
+
+int main(int, char**) {
   test_type<char>();
   test_type<int>();
   test_type<double>();
@@ -65,4 +67,6 @@
   test_type<std::max_align_t>();
   test_type<TestType1>();
   test_type<TestType2>();
+
+  return 0;
 }
Index: test/std/containers/sequences/array/types.pass.cpp
===================================================================
--- test/std/containers/sequences/array/types.pass.cpp
+++ test/std/containers/sequences/array/types.pass.cpp
@@ -47,7 +47,7 @@
     static_assert((std::is_same<typename CItT::difference_type, typename C::difference_type>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -93,4 +93,6 @@
         static_assert((std::is_same<typename C::difference_type,
             typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/sequences/deque/allocator_mismatch.fail.cpp
+++ test/std/containers/sequences/deque/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <deque>
 
-int main()
+int main(int, char**)
 {
     std::deque<int, std::allocator<long> > d;
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
+++ test/std/containers/sequences/deque/deque.capacity/access.pass.cpp
@@ -47,7 +47,7 @@
     return c;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::deque<int> c = make<std::deque<int> >(10);
@@ -87,4 +87,6 @@
         assert(c.back() == 9);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
+++ test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::deque<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
+++ test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::deque<int> C;
@@ -42,4 +42,6 @@
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp
+++ test/std/containers/sequences/deque/deque.capacity/max_size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     typedef limited_allocator<int, 10> A;
     typedef std::deque<int, A> C;
@@ -43,4 +43,6 @@
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
+++ test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
@@ -65,7 +65,7 @@
     test(c1, M);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -85,4 +85,6 @@
                 testN<std::deque<int, min_allocator<int>>>(rng[i], rng[j], rng[k]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
+++ test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
@@ -65,7 +65,7 @@
     test(c1, M, -10);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -85,4 +85,6 @@
                 testN<std::deque<int, min_allocator<int>>>(rng[i], rng[j], rng[k]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
+++ test/std/containers/sequences/deque/deque.capacity/shrink_to_fit.pass.cpp
@@ -55,7 +55,7 @@
     test(c1);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -73,4 +73,6 @@
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
+++ test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::deque<int> C;
@@ -58,4 +58,6 @@
     assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
@@ -26,7 +26,7 @@
     assert(d.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test<int>(std::allocator<int>());
     test<NotConstructible>(test_allocator<NotConstructible>(3));
@@ -36,4 +36,6 @@
     test<int>(explicit_allocator<int>());
     test<NotConstructible>(explicit_allocator<NotConstructible>{});
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/assign_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int> d;
@@ -37,4 +37,6 @@
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
@@ -149,7 +149,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   basic_test();
   test_emplacable_concept();
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
@@ -60,7 +60,7 @@
     test(c1, M, -10);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -80,4 +80,6 @@
                 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/copy.pass.cpp
@@ -25,7 +25,7 @@
     assert(c == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -57,4 +57,6 @@
         assert(v2.get_allocator() == v.get_allocator());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/copy_alloc.pass.cpp
@@ -25,7 +25,7 @@
     assert(c.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -47,4 +47,6 @@
                                                           min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp
+++ test/std/containers/sequences/deque/deque.cons/deduct.fail.cpp
@@ -25,7 +25,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -38,4 +38,6 @@
 //      deque<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/deduct.pass.cpp
@@ -29,7 +29,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -94,4 +94,6 @@
     static_assert(std::is_same_v<decltype(deq)::allocator_type, std::allocator<long double>>, "");
     assert(deq.size() == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/default.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/default.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/default.pass.cpp
@@ -29,7 +29,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<int, std::allocator<int> >();
     test<NotConstructible, limited_allocator<NotConstructible, 1> >();
@@ -37,4 +37,6 @@
     test<int, min_allocator<int> >();
     test<NotConstructible, min_allocator<NotConstructible> >();
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/default_noexcept.pass.cpp
@@ -29,7 +29,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@
         typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::deque<MoveOnly> C;
@@ -47,4 +47,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int> d = {3, 4, 5, 6};
@@ -35,4 +35,6 @@
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/initializer_list_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
@@ -38,4 +38,6 @@
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
@@ -105,7 +105,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   basic_test();
   test_emplacable_concept();
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
@@ -96,7 +96,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   basic_test();
   test_emplacable_concept();
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/move.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/move.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -68,4 +68,6 @@
         assert(c1.size() == 0);
         assert(c3.get_allocator() == c1.get_allocator());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -82,4 +82,6 @@
         assert(c3.get_allocator() == A());
         LIBCPP_ASSERT(c1.size() == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/move_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -85,4 +85,6 @@
         assert(c1.size() == 0);
         assert(c3.get_allocator() == A());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/move_assign_noexcept.pass.cpp
@@ -31,7 +31,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::deque<MoveOnly> C;
@@ -51,4 +51,6 @@
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
@@ -29,7 +29,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/op_equal.pass.cpp
@@ -24,7 +24,7 @@
     assert(c == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
         int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
@@ -59,4 +59,6 @@
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/op_equal_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int> d;
@@ -37,4 +37,6 @@
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/size.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/size.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/size.pass.cpp
@@ -86,7 +86,7 @@
     test2<T, Allocator> ( n );
 }
 
-int main()
+int main(int, char**)
 {
     test<DefaultOnly, std::allocator<DefaultOnly> >(0);
     test<DefaultOnly, std::allocator<DefaultOnly> >(1);
@@ -113,4 +113,6 @@
     test3<int, min_allocator<int>> (3);
 #endif
 
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
@@ -30,7 +30,7 @@
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<int, std::allocator<int> >(0, 5);
     test<int, std::allocator<int> >(1, 10);
@@ -48,4 +48,6 @@
 #if TEST_STD_VER >= 11
     test<int, min_allocator<int> >(4095, 90);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
@@ -30,7 +30,7 @@
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     std::allocator<int> a;
@@ -64,4 +64,6 @@
     test(4097, 157, a);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp
+++ test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp
@@ -66,7 +66,7 @@
     test0(S({1,2,1}), opt(3), S({1,2,1}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::deque<int>>();
     test<std::deque<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@
 
     test<std::deque<long>>();
     test<std::deque<double>>();
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp
+++ test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::deque<int>>();
     test<std::deque<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@
 
     test<std::deque<long>>();
     test<std::deque<double>>();
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp
@@ -17,7 +17,7 @@
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef NotConstructible T;
@@ -63,4 +63,6 @@
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
@@ -86,7 +86,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -102,4 +102,6 @@
         for (int j = 0; j < N; ++j)
             testN<std::deque<Emplaceable, min_allocator<Emplaceable>> >(rng[i], rng[j]);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
@@ -74,7 +74,7 @@
     test(c1);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -101,4 +101,6 @@
         c.emplace_front(1, 2, 3);
         assert(c.size() == 4);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
@@ -75,7 +75,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -102,4 +102,6 @@
         c.emplace_front(1, 2, 3);
         assert(c.size() == 4);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/erase_iter.invalidation.pass.cpp
@@ -54,7 +54,7 @@
     assert(&*it2 == &*it4);
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
@@ -66,4 +66,6 @@
         del_at_end(queue);
         queue.pop_back();
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
@@ -88,7 +88,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -121,4 +121,6 @@
     assert(v.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.invalidation.pass.cpp
@@ -59,7 +59,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
@@ -74,4 +74,6 @@
         }
         queue.pop_back();
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
@@ -95,7 +95,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -127,4 +127,6 @@
     assert(v.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/insert_iter_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::deque<int> d(10, 1);
@@ -59,4 +59,6 @@
     assert(d[12] == 1);
     assert(d[13] == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
@@ -259,7 +259,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -285,4 +285,6 @@
     test_move<std::deque<MoveOnly, min_allocator<MoveOnly> > >();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
@@ -91,7 +91,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -107,4 +107,6 @@
         for (int j = 0; j < N; ++j)
             testN<std::deque<MoveOnly, min_allocator<MoveOnly>> >(rng[i], rng[j]);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
@@ -132,7 +132,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -154,4 +154,6 @@
     self_reference_test<std::deque<int, min_allocator<int>> >();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
@@ -114,7 +114,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -134,4 +134,6 @@
     self_reference_test<std::deque<int, min_allocator<int>> >();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/pop_back.invalidation.pass.cpp
@@ -34,7 +34,7 @@
     assert(&*it2 == &*it4);
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
@@ -45,4 +45,6 @@
         test(queue);
         queue.pop_back();
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
@@ -63,7 +63,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -81,4 +81,6 @@
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/pop_front.invalidation.pass.cpp
@@ -34,7 +34,7 @@
     assert(&*it2 == &*it4);
 }
 
-int main()
+int main(int, char**)
 {
     std::deque<int> queue;
     for (int i = 0; i < 20; ++i)
@@ -45,4 +45,6 @@
         test(queue);
         queue.pop_back();
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
@@ -63,7 +63,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -81,4 +81,6 @@
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/push_back.pass.cpp
@@ -53,7 +53,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
@@ -69,4 +69,6 @@
         test<std::deque<int, min_allocator<int>> >(rng[j]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
@@ -64,7 +64,7 @@
 
 bool operator==(const CMyClass &lhs, const CMyClass &rhs) { return lhs.equal(rhs); }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance(42);
     {
@@ -98,4 +98,6 @@
         assert(vec==vec2);
     }
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp
@@ -58,7 +58,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049, 4094, 4095, 4096};
@@ -72,4 +72,6 @@
     for (int j = 0; j < N; ++j)
         test<std::deque<MoveOnly, min_allocator<MoveOnly>> >(rng[j]);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
@@ -62,7 +62,7 @@
     test(c1, -10);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -80,4 +80,6 @@
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
@@ -64,7 +64,7 @@
 
 bool operator==(const CMyClass &lhs, const CMyClass &rhs) { return lhs.equal(rhs); }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance(42);
     {
@@ -98,4 +98,6 @@
         assert(vec==vec2);
     }
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
+++ test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
@@ -67,7 +67,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -83,4 +83,6 @@
         for (int j = 0; j < N; ++j)
             testN<std::deque<MoveOnly, min_allocator<MoveOnly>> >(rng[i], rng[j]);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.special/copy.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.special/copy.pass.cpp
+++ test/std/containers/sequences/deque/deque.special/copy.pass.cpp
@@ -66,7 +66,7 @@
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -84,4 +84,6 @@
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
+++ test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
@@ -65,7 +65,7 @@
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -83,4 +83,6 @@
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.special/move.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.special/move.pass.cpp
+++ test/std/containers/sequences/deque/deque.special/move.pass.cpp
@@ -65,7 +65,7 @@
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -83,4 +83,6 @@
             testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
+++ test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
@@ -65,7 +65,7 @@
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -83,4 +83,6 @@
             testN<std::deque<int, min_allocator<int> > >(rng[i], rng[j]);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.special/swap.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.special/swap.pass.cpp
+++ test/std/containers/sequences/deque/deque.special/swap.pass.cpp
@@ -50,7 +50,7 @@
     assert(c2 == c1_save);
 }
 
-int main()
+int main(int, char**)
 {
     {
         int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
@@ -106,4 +106,6 @@
         assert(c2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
+++ test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
@@ -52,7 +52,7 @@
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::deque<MoveOnly> C;
@@ -85,4 +85,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/iterators.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/iterators.pass.cpp
+++ test/std/containers/sequences/deque/iterators.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::deque<int> C;
@@ -76,4 +76,6 @@
 //         assert ( ii1 != c.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/deque/types.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/types.pass.cpp
+++ test/std/containers/sequences/deque/types.pass.cpp
@@ -71,7 +71,7 @@
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<int, test_allocator<int> >();
     test<int*, std::allocator<int*> >();
@@ -100,4 +100,6 @@
             typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp
+++ test/std/containers/sequences/forwardlist/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <forward_list>
 
-int main()
+int main(int, char**)
 {
     std::forward_list<int, std::allocator<long> > fl;
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/empty.fail.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/empty.fail.cpp
+++ test/std/containers/sequences/forwardlist/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::forward_list<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/empty.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/empty.pass.cpp
+++ test/std/containers/sequences/forwardlist/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::forward_list<int> C;
@@ -42,4 +42,6 @@
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.access/front.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -57,4 +57,6 @@
         assert(*c.begin() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "../../../NotConstructible.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<NotConstructible> A;
@@ -26,4 +26,6 @@
         assert(c.get_allocator() == A(12));
         assert(c.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
@@ -17,7 +17,7 @@
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<NotConstructible> A;
@@ -45,4 +45,6 @@
         assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/assign_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -142,4 +142,6 @@
         assert(c1.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/assign_init.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@
             assert(*i == 10+n);
         assert(n == 4);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -193,4 +193,6 @@
         assert(c1.get_allocator() == A());
         assert(c0.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/assign_op_init.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@
             assert(*i == 10+n);
         assert(n == 4);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -74,4 +74,6 @@
         assert(n == 4);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/assign_size_value.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@
         assert(n == 4);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/copy.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@
         assert(c.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/copy_alloc.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -63,4 +63,6 @@
         assert(c.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.fail.cpp
@@ -25,7 +25,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -38,4 +38,6 @@
 //      forward_list<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp
@@ -29,7 +29,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -99,4 +99,6 @@
     static_assert(std::is_same_v<decltype(fwl)::allocator_type, std::allocator<long double>>, "");
     assert(std::distance(fwl.begin(), fwl.end()) == 0); // no size for forward_list
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/default.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -37,4 +37,6 @@
         assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/default_noexcept.pass.cpp
@@ -29,7 +29,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@
         typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/default_recursive.pass.cpp
@@ -19,6 +19,8 @@
     std::forward_list<X> q;
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::forward_list<MoveOnly> C;
@@ -47,4 +47,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/init.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -37,4 +37,6 @@
             assert(*i == n);
         assert(n == 10);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/init_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@
         assert(n == 10);
         assert(c.get_allocator() == A());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -67,4 +67,6 @@
         assert(c0.empty());
         assert(c.get_allocator() == A());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -67,4 +67,6 @@
         assert(c0.empty());
         assert(c.get_allocator() == A());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/move_assign_noexcept.pass.cpp
@@ -31,7 +31,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::forward_list<MoveOnly> C;
@@ -51,4 +51,6 @@
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
@@ -29,7 +29,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -44,4 +44,6 @@
         assert(n == std::end(t) - std::begin(t));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -50,4 +50,6 @@
         assert(c.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/size.pass.cpp
@@ -33,7 +33,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     { // test that the ctor is explicit
       typedef std::forward_list<DefaultOnly> C;
@@ -70,4 +70,6 @@
         check_allocator<T, min_allocator<T>> ( 3 );
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/size_value.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -41,4 +41,6 @@
         assert(n == N);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/size_value_alloc.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -46,4 +46,6 @@
         assert(c.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp
@@ -66,7 +66,7 @@
     test0(S({1,2,1}), opt(3), S({1,2,1}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::forward_list<int>>();
     test<std::forward_list<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@
 
     test<std::forward_list<long>>();
     test<std::forward_list<double>>();
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::forward_list<int>>();
     test<std::forward_list<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@
 
     test<std::forward_list<long>>();
     test<std::forward_list<double>>();
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.iter/before_begin.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -100,4 +100,6 @@
         assert(std::distance(i, c.end()) == 11);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -142,4 +142,6 @@
 //         assert ( ii1 != c.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
@@ -17,7 +17,7 @@
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef NotConstructible T;
@@ -63,4 +63,6 @@
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp
@@ -19,7 +19,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef Emplaceable T;
@@ -83,4 +83,6 @@
         assert(*next(c.begin(), 3) == Emplaceable(2, 3.5));
         assert(distance(c.begin(), c.end()) == 4);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp
@@ -21,7 +21,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef Emplaceable T;
@@ -67,4 +67,6 @@
         assert(*next(c.begin()) == Emplaceable());
         assert(distance(c.begin(), c.end()) == 2);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -151,4 +151,6 @@
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -93,4 +93,6 @@
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -83,4 +83,6 @@
         assert(distance(c.begin(), c.end()) == 4);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -69,4 +69,6 @@
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -76,4 +76,6 @@
         assert(*next(c.begin(), 4) == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -84,4 +84,6 @@
         assert(*next(c.begin(), 3) == 2);
         assert(distance(c.begin(), c.end()) == 4);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -69,4 +69,6 @@
         assert(*next(c.begin(), 4) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp
@@ -16,7 +16,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -70,4 +70,6 @@
         assert(distance(c.begin(), c.end()) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -43,4 +43,6 @@
         assert(distance(c.begin(), c.end()) == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp
@@ -57,7 +57,7 @@
     assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance;
     std::forward_list<CMyClass> vec;
@@ -70,4 +70,6 @@
     }
     catch (...) {
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef MoveOnly T;
@@ -44,4 +44,6 @@
         assert(*next(c.begin()) == 1);
         assert(distance(c.begin(), c.end()) == 2);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp
@@ -16,7 +16,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef DefaultOnly T;
@@ -110,4 +110,6 @@
         assert(*next(c.begin(), 5) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp
@@ -21,7 +21,7 @@
 #include "container_test_types.h"
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -98,4 +98,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/merge.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -44,4 +44,6 @@
         assert(c1 == c3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/merge_pred.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -45,4 +45,6 @@
         assert(c1 == c3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp
@@ -27,7 +27,7 @@
     };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -151,4 +151,6 @@
         assert(c1 == c2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp
@@ -24,7 +24,7 @@
     return i < 3;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -152,4 +152,6 @@
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/reverse.pass.cpp
@@ -30,7 +30,7 @@
         assert(*j == i);
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int> >(i);
@@ -38,4 +38,6 @@
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/sort.pass.cpp
@@ -38,7 +38,7 @@
         assert(*j == i);
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int> >(i);
@@ -46,4 +46,6 @@
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/sort_pred.pass.cpp
@@ -39,7 +39,7 @@
         assert(*j == N-1-i);
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int> >(i);
@@ -47,4 +47,6 @@
     for (int i = 0; i < 40; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
@@ -38,7 +38,7 @@
     assert(distance(c.begin(), c.end()) == size_t1 + l);
 }
 
-int main()
+int main(int, char**)
 {
     {
     // splicing different containers
@@ -72,4 +72,6 @@
     }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
@@ -75,7 +75,7 @@
     assert(distance(c.begin(), c.end()) == size_t1);
 }
 
-int main()
+int main(int, char**)
 {
     {
     // splicing different containers
@@ -137,4 +137,6 @@
     }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
@@ -75,7 +75,7 @@
     assert(distance(c.begin(), c.end()) == size_t1);
 }
 
-int main()
+int main(int, char**)
 {
     {
     // splicing different containers
@@ -165,4 +165,6 @@
     }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -116,4 +116,6 @@
         assert(c1 == c2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.pass.cpp
@@ -21,7 +21,7 @@
     return x == y;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -121,4 +121,6 @@
         assert(c1 == c2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.spec/equal.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.spec/equal.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.spec/equal.pass.cpp
@@ -47,7 +47,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 10; ++i)
         for (int j = 0; j < 10; ++j)
@@ -57,4 +57,6 @@
         for (int j = 0; j < 10; ++j)
             test<std::forward_list<int, min_allocator<int>> >(i, j);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -256,4 +256,6 @@
         assert(c2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -257,4 +257,6 @@
         assert(c2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.spec/relational.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.spec/relational.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.spec/relational.pass.cpp
@@ -52,7 +52,7 @@
         assert(c1 > c2);
 }
 
-int main()
+int main(int, char**)
 {
     for (int i = 0; i < 10; ++i)
         for (int j = 0; j < 10; ++j)
@@ -62,4 +62,6 @@
         for (int j = 0; j < 10; ++j)
             test<std::forward_list<int, min_allocator<int>> >(i, j);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
@@ -53,7 +53,7 @@
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::forward_list<MoveOnly> C;
@@ -85,4 +85,6 @@
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/incomplete.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/incomplete.pass.cpp
+++ test/std/containers/sequences/forwardlist/incomplete.pass.cpp
@@ -33,7 +33,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
   {
     A a;
@@ -49,4 +49,6 @@
     b.it2 = b.d.cbefore_begin();
   }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/max_size.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/max_size.pass.cpp
+++ test/std/containers/sequences/forwardlist/max_size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -44,4 +44,6 @@
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/forwardlist/types.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/types.pass.cpp
+++ test/std/containers/sequences/forwardlist/types.pass.cpp
@@ -31,7 +31,7 @@
 
 struct A { std::forward_list<A> v; }; // incomplete type support
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::forward_list<char> C;
@@ -72,4 +72,6 @@
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/sequences/list/allocator_mismatch.fail.cpp
+++ test/std/containers/sequences/list/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <list>
 
-int main()
+int main(int, char**)
 {
     std::list<int, std::allocator<long> > l;
+
+  return 0;
 }
Index: test/std/containers/sequences/list/incomplete_type.pass.cpp
===================================================================
--- test/std/containers/sequences/list/incomplete_type.pass.cpp
+++ test/std/containers/sequences/list/incomplete_type.pass.cpp
@@ -21,6 +21,8 @@
     std::list<A>::const_reverse_iterator crit;
 };
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
Index: test/std/containers/sequences/list/iterators.pass.cpp
===================================================================
--- test/std/containers/sequences/list/iterators.pass.cpp
+++ test/std/containers/sequences/list/iterators.pass.cpp
@@ -28,7 +28,7 @@
     int second;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -152,4 +152,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.capacity/empty.fail.cpp
===================================================================
--- test/std/containers/sequences/list/list.capacity/empty.fail.cpp
+++ test/std/containers/sequences/list/list.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::list<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.capacity/empty.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.capacity/empty.pass.cpp
+++ test/std/containers/sequences/list/list.capacity/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::list<int> C;
@@ -42,4 +42,6 @@
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.capacity/max_size.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.capacity/max_size.pass.cpp
+++ test/std/containers/sequences/list/list.capacity/max_size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     typedef limited_allocator<int, 10> A;
     typedef std::list<int, A> C;
@@ -43,4 +43,6 @@
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
+++ test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp
@@ -15,7 +15,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l(5, 2);
@@ -77,4 +77,6 @@
     }
 #endif  // __LIBCPP_MOVE
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
+++ test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
@@ -15,7 +15,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<double> l(5, 2);
@@ -49,4 +49,6 @@
         assert(l.back() == 3.5);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.capacity/size.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.capacity/size.pass.cpp
+++ test/std/containers/sequences/list/list.capacity/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::list<int> C;
@@ -58,4 +58,6 @@
     assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
+++ test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp
@@ -15,7 +15,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
@@ -40,4 +40,6 @@
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
+++ test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> d;
@@ -39,4 +39,6 @@
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
+++ test/std/containers/sequences/list/list.cons/assign_move.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -76,4 +76,6 @@
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/copy.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/copy.pass.cpp
+++ test/std/containers/sequences/list/list.cons/copy.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l(3, 2);
@@ -50,4 +50,6 @@
         assert(l2.get_allocator() == l.get_allocator());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
+++ test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
@@ -38,4 +38,6 @@
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/deduct.fail.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/deduct.fail.cpp
+++ test/std/containers/sequences/list/list.cons/deduct.fail.cpp
@@ -25,7 +25,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -38,4 +38,6 @@
 //      deque<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/deduct.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/deduct.pass.cpp
+++ test/std/containers/sequences/list/list.cons/deduct.pass.cpp
@@ -29,7 +29,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -99,4 +99,6 @@
     static_assert(std::is_same_v<decltype(lst)::allocator_type, std::allocator<long double>>, "");
     assert(lst.size() == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/default.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/default.pass.cpp
+++ test/std/containers/sequences/list/list.cons/default.pass.cpp
@@ -15,7 +15,7 @@
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l;
@@ -64,4 +64,6 @@
         assert(std::distance(l.begin(), l.end()) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
+++ test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp
@@ -29,7 +29,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@
         typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
+++ test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
@@ -15,7 +15,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l;
@@ -44,4 +44,6 @@
         assert(std::distance(l.begin(), l.end()) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::list<MoveOnly> C;
@@ -47,4 +47,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
+++ test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> d = {3, 4, 5, 6};
@@ -37,4 +37,6 @@
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
+++ test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
@@ -40,4 +40,6 @@
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
+++ test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
@@ -244,10 +244,12 @@
 
 
 
-int main() {
+int main(int, char**) {
   basic_test();
   test_emplacable_concept();
   test_emplacable_concept_with_alloc();
   test_ctor_under_alloc();
   test_ctor_under_alloc_with_alloc();
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/move.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/move.pass.cpp
+++ test/std/containers/sequences/list/list.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -59,4 +59,6 @@
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
+++ test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -72,4 +72,6 @@
         assert(l.empty());
         assert(l2.get_allocator() == min_allocator<MoveOnly>());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp
@@ -31,7 +31,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::list<MoveOnly> C;
@@ -51,4 +51,6 @@
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
+++ test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp
@@ -29,7 +29,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -49,4 +49,6 @@
         typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
+++ test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> d;
@@ -38,4 +38,6 @@
     assert(*i++ == 5);
     assert(*i++ == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/size_type.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/size_type.pass.cpp
+++ test/std/containers/sequences/list/list.cons/size_type.pass.cpp
@@ -37,7 +37,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l(3);
@@ -100,4 +100,6 @@
         assert(std::distance(l.begin(), l.end()) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
+++ test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::list<int> l(3, 2);
@@ -76,4 +76,6 @@
         assert(*i == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.erasure/erase.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.erasure/erase.pass.cpp
+++ test/std/containers/sequences/list/list.erasure/erase.pass.cpp
@@ -66,7 +66,7 @@
     test0(S({1,2,1}), opt(3), S({1,2,1}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int>>();
     test<std::list<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@
 
     test<std::list<long>>();
     test<std::list<double>>();
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp
+++ test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int>>();
     test<std::list<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@
 
     test<std::list<long>>();
     test<std::list<double>>();
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/clear.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a[] = {1, 2, 3};
@@ -34,4 +34,6 @@
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp
@@ -34,7 +34,7 @@
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
     std::list<A> c;
@@ -63,4 +63,6 @@
     assert(c.back().getd() == 4.5);
     }
 
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
@@ -34,7 +34,7 @@
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
     std::list<A> c;
@@ -84,4 +84,6 @@
     assert(c.back().geti() == 3);
     assert(c.back().getd() == 4.5);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
@@ -33,7 +33,7 @@
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
     std::list<A> c;
@@ -84,4 +84,6 @@
     assert(c.back().geti() == 2);
     assert(c.back().getd() == 3.5);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -61,4 +61,6 @@
     assert(distance(l1.begin(), l1.end()) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     {
@@ -80,4 +80,6 @@
         assert(i == l1.begin());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> d(10, 1);
@@ -61,4 +61,6 @@
     assert(*i++ == 1);
     assert(*i++ == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
@@ -81,10 +81,12 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int> >();
 #if TEST_STD_VER >= 11
     test<std::list<int, min_allocator<int>>>();
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<MoveOnly> l1;
@@ -40,4 +40,6 @@
     assert(l1.front() == MoveOnly(2));
     assert(l1.back() == MoveOnly(1));
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
@@ -44,10 +44,12 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int> >();
 #if TEST_STD_VER >= 11
     test<std::list<int, min_allocator<int>>>();
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
@@ -46,10 +46,12 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::list<int> >();
 #if TEST_STD_VER >= 11
     test<std::list<int, min_allocator<int>>>();
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a[] = {1, 2, 3};
@@ -40,4 +40,6 @@
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a[] = {1, 2, 3};
@@ -39,4 +39,6 @@
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> c;
@@ -33,4 +33,6 @@
     assert((c == std::list<int, min_allocator<int>>(a, a+5)));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp
@@ -57,7 +57,7 @@
     assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance;
     std::list<CMyClass> vec;
@@ -70,4 +70,6 @@
     }
     catch (...) {
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<MoveOnly> l1;
@@ -40,4 +40,6 @@
     assert(l1.front() == MoveOnly(1));
     assert(l1.back() == MoveOnly(2));
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<int> c;
@@ -33,4 +33,6 @@
     assert((c == std::list<int, min_allocator<int>>(a, a+5)));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp
@@ -57,7 +57,7 @@
     assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance;
     std::list<CMyClass> vec;
@@ -70,4 +70,6 @@
     }
     catch (...) {
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
+++ test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
@@ -18,7 +18,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::list<MoveOnly> l1;
@@ -40,4 +40,6 @@
     assert(l1.front() == MoveOnly(2));
     assert(l1.back() == MoveOnly(1));
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/merge.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/merge.pass.cpp
+++ test/std/containers/sequences/list/list.ops/merge.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 3, 7, 9, 10};
@@ -48,4 +48,6 @@
     assert(c2.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
+++ test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {10, 9, 7, 3, 1};
@@ -48,4 +48,6 @@
     assert(c2.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/remove.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/remove.pass.cpp
+++ test/std/containers/sequences/list/list.ops/remove.pass.cpp
@@ -32,7 +32,7 @@
   int *i_;
 };
 
-int main() {
+int main(int, char**) {
   {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
@@ -79,4 +79,6 @@
     assert((c == std::list<int, min_allocator<int>>(a2, a2 + 3)));
   }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
+++ test/std/containers/sequences/list/list.ops/remove_if.pass.cpp
@@ -29,7 +29,7 @@
 
 typedef unary_counting_predicate<bool(*)(int), int> Predicate;
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3, 4};
@@ -60,4 +60,6 @@
     assert(cp.count() == 4);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/reverse.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/reverse.pass.cpp
+++ test/std/containers/sequences/list/list.ops/reverse.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
@@ -33,4 +33,6 @@
     assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/sort.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/sort.pass.cpp
+++ test/std/containers/sequences/list/list.ops/sort.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
@@ -33,4 +33,6 @@
     assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
+++ test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp
@@ -35,7 +35,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
@@ -75,4 +75,6 @@
     assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
+++ test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     int a2[] = {4, 5, 6};
@@ -780,4 +780,6 @@
         assert(*i == 6);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
+++ test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     int a2[] = {4, 5, 6};
@@ -334,4 +334,6 @@
         assert(*i == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
+++ test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     int a2[] = {4, 5, 6};
@@ -214,4 +214,6 @@
         assert(*i == 4);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/unique.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/unique.pass.cpp
+++ test/std/containers/sequences/list/list.ops/unique.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
@@ -33,4 +33,6 @@
     assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
+++ test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp
@@ -20,7 +20,7 @@
     return x == y;
 }
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
@@ -38,4 +38,6 @@
     assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.special/swap.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.special/swap.pass.cpp
+++ test/std/containers/sequences/list/list.special/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         int a1[] = {1, 3, 7, 9, 10};
@@ -136,4 +136,6 @@
         assert(c2.get_allocator() == A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
+++ test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
@@ -52,7 +52,7 @@
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::list<MoveOnly> C;
@@ -85,4 +85,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/containers/sequences/list/types.pass.cpp
===================================================================
--- test/std/containers/sequences/list/types.pass.cpp
+++ test/std/containers/sequences/list/types.pass.cpp
@@ -28,7 +28,7 @@
 
 struct A { std::list<A> v; }; // incomplete type support
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::list<int> C;
@@ -65,4 +65,6 @@
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/nothing_to_do.pass.cpp
===================================================================
--- test/std/containers/sequences/nothing_to_do.pass.cpp
+++ test/std/containers/sequences/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
+++ test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
@@ -15,7 +15,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool, test_allocator<bool> > l(3, true, test_allocator<bool>(5));
@@ -40,4 +40,6 @@
         assert(l2.get_allocator() == min_allocator<bool>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
+++ test/std/containers/sequences/vector.bool/assign_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool> d;
@@ -37,4 +37,6 @@
     assert(d[2] == false);
     assert(d[3] == true);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/assign_move.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/assign_move.pass.cpp
+++ test/std/containers/sequences/vector.bool/assign_move.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
@@ -75,4 +75,6 @@
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/capacity.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/capacity.pass.cpp
+++ test/std/containers/sequences/vector.bool/capacity.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v;
@@ -40,4 +40,6 @@
         assert(v.capacity() >= 101);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/construct_default.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/construct_default.pass.cpp
+++ test/std/containers/sequences/vector.bool/construct_default.pass.cpp
@@ -59,7 +59,7 @@
     assert(c.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     test0<std::vector<bool> >();
@@ -75,4 +75,6 @@
     test1<std::vector<bool, explicit_allocator<bool> > >(explicit_allocator<bool>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
+++ test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
@@ -30,7 +30,7 @@
         assert(*i == *first);
 }
 
-int main()
+int main(int, char**)
 {
     bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
     bool* an = a + sizeof(a)/sizeof(a[0]);
@@ -46,4 +46,6 @@
     test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(a, an);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
+++ test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
@@ -31,7 +31,7 @@
         assert(*i == *first);
 }
 
-int main()
+int main(int, char**)
 {
     bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
     bool* an = a + sizeof(a)/sizeof(a[0]);
@@ -53,4 +53,6 @@
     test<std::vector<bool, min_allocator<bool>> >(a, an, alloc);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/construct_size.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/construct_size.pass.cpp
+++ test/std/containers/sequences/vector.bool/construct_size.pass.cpp
@@ -56,11 +56,13 @@
     test2<C> ( n );
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<bool> >(50);
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50);
     test2<std::vector<bool, test_allocator<bool>> >( 100, test_allocator<bool>(23));
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
+++ test/std/containers/sequences/vector.bool/construct_size_value.pass.cpp
@@ -28,10 +28,12 @@
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<bool> >(50, true);
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50, true);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
+++ test/std/containers/sequences/vector.bool/construct_size_value_alloc.pass.cpp
@@ -30,10 +30,12 @@
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<bool> >(50, true, std::allocator<bool>());
 #if TEST_STD_VER >= 11
     test<std::vector<bool, min_allocator<bool>> >(50, true, min_allocator<bool>());
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/copy.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/copy.pass.cpp
+++ test/std/containers/sequences/vector.bool/copy.pass.cpp
@@ -29,7 +29,7 @@
     assert(c == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
         bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
@@ -61,4 +61,6 @@
         assert(v2.get_allocator() == v.get_allocator());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
+++ test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
@@ -28,7 +28,7 @@
     assert(c == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
         bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
@@ -60,4 +60,6 @@
         assert(l2.get_allocator() == min_allocator<bool>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
+++ test/std/containers/sequences/vector.bool/default_noexcept.pass.cpp
@@ -30,7 +30,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -50,4 +50,6 @@
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
+++ test/std/containers/sequences/vector.bool/dtor_noexcept.pass.cpp
@@ -26,7 +26,7 @@
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<bool> C;
@@ -46,4 +46,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/emplace.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/emplace.pass.cpp
+++ test/std/containers/sequences/vector.bool/emplace.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<bool> C;
@@ -63,4 +63,6 @@
         assert(c[1] == true);
         assert(c.back() == true);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
+++ test/std/containers/sequences/vector.bool/emplace_back.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<bool> C;
@@ -87,4 +87,6 @@
         assert(c[1] == true);
         assert(c.back() == true);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/empty.fail.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/empty.fail.cpp
+++ test/std/containers/sequences/vector.bool/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::vector<bool> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/empty.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/empty.pass.cpp
+++ test/std/containers/sequences/vector.bool/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<bool> C;
@@ -42,4 +42,6 @@
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp
+++ test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp
@@ -18,10 +18,12 @@
 #include "poisoned_hash_helper.hpp"
 #include "min_allocator.h"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::vector<bool> >();
     test_hash_enabled_for_type<std::vector<bool, min_allocator<bool>>>();
   }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
+++ test/std/containers/sequences/vector.bool/erase_iter.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     bool a1[] = {1, 0, 1};
     {
@@ -61,4 +61,6 @@
     assert(distance(l1.begin(), l1.end()) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
+++ test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     bool a1[] = {1, 0, 1};
     {
@@ -81,4 +81,6 @@
         assert(i == l1.begin());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/find.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/find.pass.cpp
+++ test/std/containers/sequences/vector.bool/find.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         for (unsigned i = 1; i < 256; ++i)
@@ -38,4 +38,6 @@
             assert(b.end() == j);
         }
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
+++ test/std/containers/sequences/vector.bool/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool> d = {true, false, false, true};
@@ -35,4 +35,6 @@
     assert(d[2] == false);
     assert(d[3] == true);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
+++ test/std/containers/sequences/vector.bool/initializer_list_alloc.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool, test_allocator<bool>> d({true, false, false, true}, test_allocator<bool>(3));
@@ -38,4 +38,6 @@
     assert(d[2] == false);
     assert(d[3] == true);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
+++ test/std/containers/sequences/vector.bool/insert_iter_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool> d(10, true);
@@ -59,4 +59,6 @@
     assert(d[12] == true);
     assert(d[13] == true);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
+++ test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -125,4 +125,6 @@
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
+++ test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -78,4 +78,6 @@
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
+++ test/std/containers/sequences/vector.bool/insert_iter_value.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -74,4 +74,6 @@
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/iterators.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/iterators.pass.cpp
+++ test/std/containers/sequences/vector.bool/iterators.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef bool T;
@@ -120,4 +120,6 @@
         assert (ii1 - cii == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/move.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/move.pass.cpp
+++ test/std/containers/sequences/vector.bool/move.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
@@ -89,4 +89,6 @@
         assert(a.get_data() == 42);
       }
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
+++ test/std/containers/sequences/vector.bool/move_alloc.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
@@ -71,4 +71,6 @@
         assert(l.empty());
         assert(l2.get_allocator() == min_allocator<bool>());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
+++ test/std/containers/sequences/vector.bool/move_assign_noexcept.pass.cpp
@@ -56,7 +56,7 @@
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -97,4 +97,6 @@
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
+++ test/std/containers/sequences/vector.bool/move_noexcept.pass.cpp
@@ -28,7 +28,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -56,4 +56,6 @@
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
 #endif
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
+++ test/std/containers/sequences/vector.bool/op_equal_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<bool> d;
@@ -37,4 +37,6 @@
     assert(d[2] == false);
     assert(d[3] == true);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/push_back.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/push_back.pass.cpp
+++ test/std/containers/sequences/vector.bool/push_back.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         bool a[] = {0, 1, 1, 0, 1, 0, 0};
@@ -45,4 +45,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
+++ test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 
     bool a[] = {false, true, false, true};
@@ -35,4 +35,6 @@
     v.swap(r1, r2);
     assert( r1);
     assert(!r2);
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/reserve.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/reserve.pass.cpp
+++ test/std/containers/sequences/vector.bool/reserve.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v;
@@ -50,4 +50,6 @@
         assert(v.capacity() >= 150);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/resize_size.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/resize_size.pass.cpp
+++ test/std/containers/sequences/vector.bool/resize_size.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -46,4 +46,6 @@
         assert(v.capacity() >= 400);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
+++ test/std/containers/sequences/vector.bool/resize_size_value.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -48,4 +48,6 @@
             assert(v[i] == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
+++ test/std/containers/sequences/vector.bool/shrink_to_fit.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v(100);
@@ -34,4 +34,6 @@
         assert(v.size() >= 101);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/size.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/size.pass.cpp
+++ test/std/containers/sequences/vector.bool/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<bool> C;
@@ -58,4 +58,6 @@
     assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/swap.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/swap.pass.cpp
+++ test/std/containers/sequences/vector.bool/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<bool> v1(100);
@@ -94,4 +94,6 @@
         assert(v[1] == true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
+++ test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
@@ -52,7 +52,7 @@
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -89,4 +89,6 @@
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/types.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/types.pass.cpp
+++ test/std/containers/sequences/vector.bool/types.pass.cpp
@@ -67,7 +67,7 @@
         std::reverse_iterator<typename C::const_iterator> >::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<test_allocator<bool> >();
     test<std::allocator<bool> >();
@@ -76,4 +76,6 @@
 #if TEST_STD_VER >= 11
     test<min_allocator<bool> >();
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
===================================================================
--- test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
+++ test/std/containers/sequences/vector.bool/vector_bool.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<bool> T;
@@ -50,4 +50,6 @@
     assert(h(vb) != 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/sequences/vector/allocator_mismatch.fail.cpp
+++ test/std/containers/sequences/vector/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <vector>
 
-int main()
+int main(int, char**)
 {
     std::vector<int, std::allocator<long> > v;
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/contiguous.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/contiguous.pass.cpp
+++ test/std/containers/sequences/vector/contiguous.pass.cpp
@@ -23,7 +23,7 @@
         assert ( *(c.begin() + static_cast<typename C::difference_type>(i)) == *(std::addressof(*c.begin()) + i));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -48,4 +48,6 @@
     test_contiguous(C(9, 11.0, A{}));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/iterators.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/iterators.pass.cpp
+++ test/std/containers/sequences/vector/iterators.pass.cpp
@@ -28,7 +28,7 @@
     int second;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -166,4 +166,6 @@
         assert (ii1 - cii == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/types.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/types.pass.cpp
+++ test/std/containers/sequences/vector/types.pass.cpp
@@ -78,7 +78,7 @@
         std::reverse_iterator<typename C::const_iterator> >::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<int, test_allocator<int> >();
     test<int*, std::allocator<int*> >();
@@ -104,4 +104,6 @@
 //         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
+++ test/std/containers/sequences/vector/vector.capacity/capacity.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v;
@@ -44,4 +44,6 @@
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
+++ test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::vector<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
+++ test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> C;
@@ -42,4 +42,6 @@
     assert(c.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp
+++ test/std/containers/sequences/vector/vector.capacity/max_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   {
     typedef limited_allocator<int, 10> A;
     typedef std::vector<int, A> C;
@@ -44,4 +44,6 @@
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(c.get_allocator()));
   }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
+++ test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v;
@@ -66,4 +66,6 @@
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
+++ test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -80,4 +80,6 @@
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
+++ test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -73,4 +73,6 @@
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
+++ test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -58,4 +58,6 @@
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
+++ test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> C;
@@ -58,4 +58,6 @@
     assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
+++ test/std/containers/sequences/vector/vector.capacity/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v1(100);
@@ -46,4 +46,6 @@
         assert(is_contiguous_container_asan_correct(v2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp
@@ -15,7 +15,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
@@ -40,4 +40,6 @@
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/assign_initializer_list.pass.cpp
@@ -30,7 +30,7 @@
     assert(v[3] == 6);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> V;
@@ -48,4 +48,6 @@
     test(d1);
     test(d2);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
@@ -69,7 +69,9 @@
 
 
 
-int main()
+int main(int, char**)
 {
     test_emplaceable_concept();
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/assign_move.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -95,4 +95,6 @@
         assert(l2.get_allocator() == lo.get_allocator());
         assert(is_contiguous_container_asan_correct(l2));
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/assign_size_value.pass.cpp
@@ -29,7 +29,7 @@
     assert(std::all_of(v.begin(), v.end(), is6));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> V;
@@ -50,4 +50,6 @@
     test(d2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
@@ -60,7 +60,7 @@
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
-int main()
+int main(int, char**)
 {
     {
     test0<std::vector<int> >();
@@ -98,4 +98,6 @@
         assert(v.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -176,9 +176,11 @@
 }
 
 
-int main() {
+int main(int, char**) {
   basic_test_cases();
   emplaceable_concept_tests(); // See PR34898
   test_ctor_under_alloc();
   test_ctor_with_different_value_type();
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -162,8 +162,10 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   basic_tests();
   emplaceable_concept_tests(); // See PR34898
   test_ctor_under_alloc();
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/construct_size.pass.cpp
@@ -60,7 +60,7 @@
     test2<C> ( n );
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >(50);
     test<std::vector<DefaultOnly> >(500);
@@ -71,4 +71,6 @@
     test2<std::vector<DefaultOnly, test_allocator<DefaultOnly>> >( 100, test_allocator<DefaultOnly>(23));
     assert(DefaultOnly::count == 0);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
@@ -30,7 +30,7 @@
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >(50, 3);
     // Add 1 for implementations that dynamically allocate a container proxy.
@@ -38,4 +38,6 @@
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(50, 3);
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/construct_size_value_alloc.pass.cpp
@@ -31,10 +31,12 @@
         assert(*i == x);
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >(50, 3, std::allocator<int>());
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(50, 3, min_allocator<int>());
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
@@ -30,7 +30,7 @@
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
-int main()
+int main(int, char**)
 {
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
@@ -74,4 +74,6 @@
         assert(is_contiguous_container_asan_correct(v2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
@@ -30,7 +30,7 @@
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
-int main()
+int main(int, char**)
 {
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
@@ -62,4 +62,6 @@
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp
+++ test/std/containers/sequences/vector/vector.cons/deduct.fail.cpp
@@ -23,7 +23,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -36,4 +36,6 @@
 //      deque<allocator<int>, allocator<allocator<int>>>
     }
 
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/deduct.pass.cpp
@@ -29,7 +29,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -112,4 +112,6 @@
     static_assert(std::is_same_v<decltype(vec)::allocator_type, std::allocator<bool>>, "");
     assert(vec.size() == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/default.recursive.pass.cpp
@@ -17,6 +17,8 @@
     std::vector<X> q;
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/default_noexcept.pass.cpp
@@ -29,7 +29,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -47,4 +47,6 @@
         typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/dtor_noexcept.pass.cpp
@@ -27,7 +27,7 @@
     ~some_alloc() noexcept(false);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -47,4 +47,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int> d = {3, 4, 5, 6};
@@ -37,4 +37,6 @@
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/initializer_list_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
@@ -41,4 +41,6 @@
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/move.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/move.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/move.pass.cpp
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -129,4 +129,6 @@
         assert(a.get_data() == 42);
       }
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/move_alloc.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5));
@@ -93,4 +93,6 @@
         assert(l2.get_allocator() == min_allocator<MoveOnly>());
         assert(is_contiguous_container_asan_correct(l2));
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/move_assign_noexcept.pass.cpp
@@ -57,7 +57,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -91,4 +91,6 @@
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/move_noexcept.pass.cpp
@@ -28,7 +28,7 @@
     some_alloc(const some_alloc&);
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -51,4 +51,6 @@
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
 #endif
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/op_equal_initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int> d;
@@ -40,4 +40,6 @@
     assert(d[2] == 5);
     assert(d[3] == 6);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.data/data.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.data/data.pass.cpp
+++ test/std/containers/sequences/vector/vector.data/data.pass.cpp
@@ -25,7 +25,7 @@
     int i_;
     };
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v;
@@ -59,4 +59,6 @@
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
+++ test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
@@ -25,7 +25,7 @@
     int i_;
     };
 
-int main()
+int main(int, char**)
 {
     {
         const std::vector<int> v;
@@ -59,4 +59,6 @@
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp
+++ test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp
@@ -66,7 +66,7 @@
     test0(S({1,2,1}), opt(3), S({1,2,1}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int>>();
     test<std::vector<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@
 
     test<std::vector<long>>();
     test<std::vector<double>>();
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp
+++ test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp
@@ -66,7 +66,7 @@
     test0(S({1,2,3}), False, S({1,2,3}));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int>>();
     test<std::vector<int, min_allocator<int>>> ();
@@ -74,4 +74,6 @@
 
     test<std::vector<long>>();
     test<std::vector<double>>();
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/clear.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     int a[] = {1, 2, 3};
@@ -39,4 +39,6 @@
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp
@@ -52,7 +52,7 @@
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<A> c;
@@ -132,4 +132,6 @@
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp
@@ -53,7 +53,7 @@
     double getd() const {return d_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<A> c;
@@ -144,4 +144,6 @@
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v;
@@ -56,4 +56,6 @@
         assert(v[0] == 3);
         assert(is_contiguous_container_asan_correct(v));
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp
@@ -32,7 +32,7 @@
 bool Throws::sThrows = false;
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -99,4 +99,6 @@
     assert(v.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp
@@ -32,7 +32,7 @@
 bool Throws::sThrows = false;
 #endif
 
-int main()
+int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     {
@@ -152,4 +152,6 @@
     assert(v.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/insert_iter_initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::vector<int> d(10, 1);
@@ -62,4 +62,6 @@
     assert(d[12] == 1);
     assert(d[13] == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<int> V;
@@ -171,4 +171,6 @@
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly> v(100);
@@ -62,4 +62,6 @@
         for (++j; j < 101; ++j)
             assert(v[j] == MoveOnly());
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -111,4 +111,6 @@
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> v(100);
@@ -93,4 +93,6 @@
             assert(v[j] == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> c;
@@ -37,4 +37,6 @@
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
@@ -17,7 +17,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<int> c;
@@ -108,4 +108,6 @@
             assert(c[j] == j);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp
@@ -64,7 +64,7 @@
 
 bool operator==(const CMyClass &lhs, const CMyClass &rhs) { return lhs.equal(rhs); }
 
-int main()
+int main(int, char**)
 {
     CMyClass instance(42);
     std::vector<CMyClass> vec;
@@ -85,4 +85,6 @@
         assert(is_contiguous_container_asan_correct(vec));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
+++ test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::vector<MoveOnly> c;
@@ -109,4 +109,6 @@
         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.special/swap.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.special/swap.pass.cpp
+++ test/std/containers/sequences/vector/vector.special/swap.pass.cpp
@@ -18,7 +18,7 @@
 #include "min_allocator.h"
 #include "asan_testing.h"
 
-int main()
+int main(int, char**)
 {
     {
         int a1[] = {1, 3, 7, 9, 10};
@@ -178,4 +178,6 @@
         assert(is_contiguous_container_asan_correct(c2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
+++ test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
@@ -53,7 +53,7 @@
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::vector<MoveOnly> C;
@@ -85,4 +85,6 @@
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/iterator_difference_type.pass.cpp
===================================================================
--- test/std/containers/unord/iterator_difference_type.pass.cpp
+++ test/std/containers/unord/iterator_difference_type.pass.cpp
@@ -73,7 +73,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef std::unordered_map<int, int> Map;
     typedef std::pair<const int, int> ValueTp;
@@ -150,4 +150,6 @@
     testUnorderedSet<Set, ValueTp, min_pointer<const ValueTp>>();
   }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp
+++ test/std/containers/unord/unord.map/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <unordered_map>
 
-int main()
+int main(int, char**)
 {
     std::unordered_map<int, int, std::hash<int>, std::less<int>, std::allocator<long> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/bucket.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/bucket.pass.cpp
+++ test/std/containers/unord/unord.map/bucket.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -74,4 +74,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/bucket_count.pass.cpp
+++ test/std/containers/unord/unord.map/bucket_count.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -71,4 +71,6 @@
         assert(c.bucket_count() >= 8);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/bucket_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/bucket_size.pass.cpp
+++ test/std/containers/unord/unord.map/bucket_size.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -78,4 +78,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/compare.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/compare.pass.cpp
+++ test/std/containers/unord/unord.map/compare.pass.cpp
@@ -32,7 +32,7 @@
     };
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::unordered_map<Key, int> MapT;
     typedef MapT::iterator Iter;
@@ -42,4 +42,6 @@
     std::pair<Iter, bool> result = map.insert(std::make_pair(Key(0), 42));
     assert(result.second);
     assert(result.first->second == 42);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/count.pass.cpp
+++ test/std/containers/unord/unord.map/count.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -61,4 +61,6 @@
         assert(c.count(5) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/empty.fail.cpp
===================================================================
--- test/std/containers/unord/unord.map/empty.fail.cpp
+++ test/std/containers/unord/unord.map/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::unordered_map<int, int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/empty.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/empty.pass.cpp
+++ test/std/containers/unord/unord.map/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, double> M;
@@ -42,4 +42,6 @@
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/eq.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/eq.pass.cpp
+++ test/std/containers/unord/unord.map/eq.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -159,4 +159,6 @@
         assert(!(c1 != c2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/equal_range_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/equal_range_const.pass.cpp
+++ test/std/containers/unord/unord.map/equal_range_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -71,4 +71,6 @@
         assert(std::distance(r.first, r.second) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
+++ test/std/containers/unord/unord.map/equal_range_non_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -71,4 +71,6 @@
         assert(std::distance(r.first, r.second) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/erase_if.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/erase_if.pass.cpp
+++ test/std/containers/unord/unord.map/erase_if.pass.cpp
@@ -67,7 +67,7 @@
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::unordered_map<int, int>>();
     test<std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>>> ();
@@ -75,5 +75,7 @@
 
     test<std::unordered_map<long, short>>();
     test<std::unordered_map<short, double>>();
+
+  return 0;
 }
 
Index: test/std/containers/unord/unord.map/find_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/find_const.pass.cpp
+++ test/std/containers/unord/unord.map/find_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -67,4 +67,6 @@
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/find_non_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/find_non_const.pass.cpp
+++ test/std/containers/unord/unord.map/find_non_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -67,4 +67,6 @@
         assert(i == c.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/incomplete_type.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/incomplete_type.pass.cpp
+++ test/std/containers/unord/unord.map/incomplete_type.pass.cpp
@@ -31,6 +31,8 @@
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/iterators.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/iterators.pass.cpp
+++ test/std/containers/unord/unord.map/iterators.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -126,4 +126,6 @@
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/load_factor.pass.cpp
+++ test/std/containers/unord/unord.map/load_factor.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -73,4 +73,6 @@
         assert(c.load_factor() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/local_iterators.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/local_iterators.pass.cpp
+++ test/std/containers/unord/unord.map/local_iterators.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -417,4 +417,6 @@
         assert(i->second == "four");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
+++ test/std/containers/unord/unord.map/max_bucket_count.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -36,4 +36,6 @@
         assert(c.max_bucket_count() > 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/max_load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/max_load_factor.pass.cpp
+++ test/std/containers/unord/unord.map/max_load_factor.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -65,4 +65,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/max_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/max_size.pass.cpp
+++ test/std/containers/unord/unord.map/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::pair<const int, int> KV;
   {
@@ -49,4 +49,6 @@
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/rehash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/rehash.pass.cpp
+++ test/std/containers/unord/unord.map/rehash.pass.cpp
@@ -37,7 +37,7 @@
     assert(c.at(4) == "four");
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -100,4 +100,6 @@
         test(c);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/reserve.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/reserve.pass.cpp
+++ test/std/containers/unord/unord.map/reserve.pass.cpp
@@ -46,7 +46,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -104,4 +104,6 @@
     }
 #endif
     reserve_invariant(20);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/size.pass.cpp
+++ test/std/containers/unord/unord.map/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_map<int, double> M;
@@ -58,4 +58,6 @@
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/swap_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/swap_member.pass.cpp
+++ test/std/containers/unord/unord.map/swap_member.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -567,4 +567,6 @@
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/types.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/types.pass.cpp
+++ test/std/containers/unord/unord.map/types.pass.cpp
@@ -32,7 +32,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<char, short> C;
@@ -68,4 +68,6 @@
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -126,4 +126,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -185,4 +185,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
@@ -27,7 +27,7 @@
 #include "../../../test_hash.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::allocator<std::pair<const int, std::string> > A;
@@ -93,4 +93,6 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -214,4 +214,6 @@
         assert(c.max_load_factor() == 1);
         assert(c0.size() == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
@@ -26,6 +26,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_map<int, int, std::hash<int>, Comp<int> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -148,4 +148,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -148,4 +148,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -108,4 +108,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/default_noexcept.pass.cpp
@@ -45,7 +45,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -72,4 +72,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/dtor_noexcept.pass.cpp
@@ -38,7 +38,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
@@ -65,4 +65,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
@@ -26,6 +26,8 @@
 };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_map<int, int, Hash<int> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -159,4 +159,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif // TEST_STD_VER > 11
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -97,4 +97,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -99,4 +99,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -102,4 +102,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -140,4 +140,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -176,4 +176,6 @@
         assert(s2.size() == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, std::string> P;
@@ -195,4 +195,6 @@
 
         assert(c0.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/move_assign_noexcept.pass.cpp
@@ -44,7 +44,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
@@ -71,4 +71,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/move_noexcept.pass.cpp
@@ -41,7 +41,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -68,4 +68,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -169,4 +169,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -104,4 +104,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -107,4 +107,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -109,4 +109,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string,
@@ -150,4 +150,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -66,4 +66,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -66,4 +66,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -70,4 +70,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -72,4 +72,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<NotConstructible, NotConstructible,
@@ -96,4 +96,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -140,4 +140,6 @@
 #endif
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.elem/index.pass.cpp
@@ -28,7 +28,7 @@
 #include "container_test_types.h"
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -159,4 +159,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.elem/index_tuple.pass.cpp
@@ -28,8 +28,10 @@
     size_t operator()(const tuple<int,int>&) const {return 0;}
 };
 
-int main()
+int main(int, char**)
 {
     unordered_map<tuple<int,int>, size_t, my_hash> m;
     m[make_tuple(2,3)]=7;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/clear.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -60,4 +60,6 @@
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, Emplaceable> C;
@@ -74,4 +74,6 @@
         assert(r.first->first == 5);
         assert(r.first->second == Emplaceable(6, 7));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/emplace_hint.pass.cpp
@@ -24,7 +24,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, Emplaceable> C;
@@ -71,4 +71,6 @@
         assert(r->first == 5);
         assert(r->second == Emplaceable(6, 7));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/erase_const_iter.pass.cpp
@@ -30,7 +30,7 @@
 bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -89,4 +89,6 @@
             m.erase(it);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <unordered_map>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -31,8 +31,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <exception>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -34,8 +34,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -32,8 +32,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/erase_key.pass.cpp
@@ -38,7 +38,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -174,4 +174,6 @@
     assert (only_deletions (m, m2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/erase_range.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -95,4 +95,6 @@
         assert(k == c.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/extract_iterator.pass.cpp
@@ -40,7 +40,7 @@
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using map_type = std::unordered_map<int, int>;
@@ -63,4 +63,6 @@
         min_alloc_map m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
         test(m);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/extract_key.pass.cpp
@@ -45,7 +45,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_map<int, int> m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}, {6,6}};
@@ -72,4 +72,6 @@
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_and_emplace_allocator_requirements.pass.cpp
@@ -21,10 +21,12 @@
 #include "container_test_types.h"
 #include "../../../map_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMapInsert<TCT::unordered_map<> >();
   testMapInsertHint<TCT::unordered_map<> >();
   testMapEmplace<TCT::unordered_map<> >();
   testMapEmplaceHint<TCT::unordered_map<> >();
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp
@@ -65,7 +65,7 @@
     assert(r.first->second == 3);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<double, int> M;
@@ -78,4 +78,6 @@
         do_insert_cv_test<M>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -56,7 +56,7 @@
     assert(r->second == 4);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_map<double, int> >();
 #if TEST_STD_VER >= 11
@@ -80,4 +80,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp
@@ -28,7 +28,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<double, int> C;
@@ -173,4 +173,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_init.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -66,4 +66,6 @@
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type.pass.cpp
@@ -74,10 +74,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_map<int, int> m;
     test(m);
     std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_node_type_hint.pass.cpp
@@ -54,10 +54,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_map<int, int> m;
     test(m);
     std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
@@ -61,7 +61,7 @@
     };
 }
 
-int main()
+int main(int, char**)
 {
 
     { // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
@@ -188,4 +188,6 @@
         assert(r->second.get() == 5);  // value
     }
 
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<int, std::string> C;
@@ -67,4 +67,6 @@
         assert(c.at(4) == "four");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp
@@ -24,7 +24,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_map<double, int> C;
@@ -172,4 +172,6 @@
         assert(r.first->first == 5.5);
         assert(r.first->second == 4);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
@@ -49,7 +49,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_map<int, int> src{{1, 0}, {3, 0}, {5, 0}};
@@ -153,4 +153,5 @@
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.modifiers/try.emplace.pass.cpp
@@ -60,7 +60,7 @@
     };
 }
 
-int main()
+int main(int, char**)
 {
 
     { // pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
@@ -185,4 +185,6 @@
         assert(r->first.get()  == 3); // key
         assert(r->second.get() == 4); // value
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp
@@ -21,7 +21,7 @@
 #include <unordered_map>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -40,4 +40,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
@@ -119,7 +119,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> MapType;
     {
@@ -188,4 +188,6 @@
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -567,4 +567,6 @@
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp
+++ test/std/containers/unord/unord.multimap/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <unordered_map>
 
-int main()
+int main(int, char**)
 {
     std::unordered_multimap<int, int, std::hash<int>, std::less<int>, std::allocator<long> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/bucket.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/bucket.pass.cpp
+++ test/std/containers/unord/unord.multimap/bucket.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -74,4 +74,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
+++ test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -44,4 +44,6 @@
         const C c(std::begin(a), std::end(a));
         assert(c.bucket_count() >= 8);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
+++ test/std/containers/unord/unord.multimap/bucket_size.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -82,4 +82,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/count.pass.cpp
+++ test/std/containers/unord/unord.multimap/count.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -67,4 +67,6 @@
         assert(c.count(5) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
+++ test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
@@ -52,8 +52,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
+++ test/std/containers/unord/unord.multimap/db_iterators_8.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
@@ -48,8 +48,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
+++ test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
@@ -49,8 +49,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
+++ test/std/containers/unord/unord.multimap/db_local_iterators_8.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
@@ -46,8 +46,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/empty.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/empty.fail.cpp
+++ test/std/containers/unord/unord.multimap/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::unordered_multimap<int, int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/empty.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/empty.pass.cpp
+++ test/std/containers/unord/unord.multimap/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, double> M;
@@ -42,4 +42,6 @@
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/eq.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/eq.pass.cpp
+++ test/std/containers/unord/unord.multimap/eq.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -177,4 +177,6 @@
         assert(!(c1 != c2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
+++ test/std/containers/unord/unord.multimap/equal_range_const.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -100,4 +100,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
+++ test/std/containers/unord/unord.multimap/equal_range_non_const.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -100,4 +100,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/erase_if.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/erase_if.pass.cpp
+++ test/std/containers/unord/unord.multimap/erase_if.pass.cpp
@@ -78,7 +78,7 @@
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::unordered_multimap<int, int>>();
     test<std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>>> ();
@@ -86,4 +86,6 @@
 
     test<std::unordered_multimap<long, short>>();
     test<std::unordered_multimap<short, double>>();
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/find_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/find_const.pass.cpp
+++ test/std/containers/unord/unord.multimap/find_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -67,4 +67,6 @@
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
+++ test/std/containers/unord/unord.multimap/find_non_const.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -67,4 +67,6 @@
         assert(i == c.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/incomplete.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/incomplete.pass.cpp
+++ test/std/containers/unord/unord.multimap/incomplete.pass.cpp
@@ -31,6 +31,8 @@
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/iterators.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/iterators.fail.cpp
+++ test/std/containers/unord/unord.multimap/iterators.fail.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -67,4 +67,6 @@
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/iterators.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/iterators.pass.cpp
+++ test/std/containers/unord/unord.multimap/iterators.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -132,4 +132,6 @@
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/load_factor.pass.cpp
+++ test/std/containers/unord/unord.multimap/load_factor.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -72,4 +72,6 @@
         assert(c.load_factor() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
+++ test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -284,4 +284,6 @@
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
+++ test/std/containers/unord/unord.multimap/local_iterators.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -658,4 +658,6 @@
         assert(std::distance(i, j) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
+++ test/std/containers/unord/unord.multimap/max_bucket_count.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -35,4 +35,6 @@
         assert(c.max_bucket_count() > 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
+++ test/std/containers/unord/unord.multimap/max_load_factor.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -63,4 +63,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/max_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/max_size.pass.cpp
+++ test/std/containers/unord/unord.multimap/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::pair<const int, int> KV;
   {
@@ -51,4 +51,6 @@
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/rehash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/rehash.pass.cpp
+++ test/std/containers/unord/unord.multimap/rehash.pass.cpp
@@ -81,7 +81,7 @@
     assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -144,4 +144,6 @@
         test(c);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/reserve.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/reserve.pass.cpp
+++ test/std/containers/unord/unord.multimap/reserve.pass.cpp
@@ -61,7 +61,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -119,4 +119,6 @@
     }
 #endif
     reserve_invariant(20);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/scary.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/scary.pass.cpp
+++ test/std/containers/unord/unord.multimap/scary.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <unordered_map>
 
-int main()
+int main(int, char**)
 {
     typedef std::unordered_map<int, int> M1;
     typedef std::unordered_multimap<int, int> M2;
     M2::iterator i;
     M1::iterator j = i;
     ((void)j);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/size.pass.cpp
+++ test/std/containers/unord/unord.multimap/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multimap<int, double> M;
@@ -58,4 +58,6 @@
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/swap_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/swap_member.pass.cpp
+++ test/std/containers/unord/unord.multimap/swap_member.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -653,4 +653,6 @@
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/types.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/types.pass.cpp
+++ test/std/containers/unord/unord.multimap/types.pass.cpp
@@ -32,7 +32,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<char, short> C;
@@ -68,4 +68,6 @@
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -126,4 +126,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -227,4 +227,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -142,4 +142,6 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
@@ -291,4 +291,6 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
@@ -26,6 +26,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_multimap<int, int, std::hash<int>, Comp<int> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -190,4 +190,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -190,4 +190,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -108,4 +108,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default_noexcept.pass.cpp
@@ -44,7 +44,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -71,4 +71,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/dtor_noexcept.pass.cpp
@@ -37,7 +37,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
@@ -64,4 +64,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
@@ -26,6 +26,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_multimap<int, int, Hash<int> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -251,4 +251,6 @@
         assert(!(c.get_allocator() == A()));
     }
 #endif // TEST_STD_VER > 11
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -141,4 +141,6 @@
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -143,4 +143,6 @@
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -146,4 +146,6 @@
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -207,4 +207,6 @@
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -221,4 +221,6 @@
         assert(s2.size() == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, std::string> P;
@@ -289,4 +289,6 @@
 
         assert(c0.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_assign_noexcept.pass.cpp
@@ -43,7 +43,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
@@ -70,4 +70,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_noexcept.pass.cpp
@@ -40,7 +40,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -67,4 +67,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -262,4 +262,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -148,4 +148,6 @@
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -151,4 +151,6 @@
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
@@ -31,7 +31,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -153,4 +153,6 @@
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -32,7 +32,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string,
@@ -217,4 +217,6 @@
         assert(c.get_allocator() == A{});
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -66,4 +66,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -66,4 +66,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -70,4 +70,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -72,4 +72,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<NotConstructible, NotConstructible,
@@ -96,4 +96,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/clear.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -60,4 +60,6 @@
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, Emplaceable> C;
@@ -68,4 +68,6 @@
         assert(r->first == 5);
         assert(r->second == Emplaceable(6, 7));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/emplace_hint.pass.cpp
@@ -25,7 +25,7 @@
 #include "min_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, Emplaceable> C;
@@ -88,4 +88,6 @@
         assert(r->first == 3);
         LIBCPP_ASSERT(r->second == Emplaceable(5, 6));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
@@ -30,7 +30,7 @@
 bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -143,4 +143,6 @@
             m.erase(it);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <unordered_map>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -31,8 +31,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <exception>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -34,8 +34,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -33,8 +33,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
@@ -32,8 +32,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
@@ -37,7 +37,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -385,4 +385,6 @@
     assert (only_deletions (m, m2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -176,4 +176,6 @@
         assert(k == c.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_iterator.pass.cpp
@@ -40,7 +40,7 @@
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using map_type = std::unordered_multimap<int, int>;
@@ -63,4 +63,6 @@
         min_alloc_map m = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}};
         test(m);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/extract_key.pass.cpp
@@ -45,7 +45,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_multimap<int, int> m =
@@ -73,4 +73,6 @@
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_allocator_requirements.pass.cpp
@@ -19,8 +19,10 @@
 #include "container_test_types.h"
 #include "../../../map_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMultimapInsert<TCT::unordered_multimap<> >();
   testMultimapInsertHint<TCT::unordered_multimap<> >();
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp
@@ -51,7 +51,7 @@
     assert(r->second == 4);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_multimap<double, int> >();
 #if TEST_STD_VER >= 11
@@ -61,4 +61,6 @@
         do_insert_const_lvalue_test<C>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp
@@ -56,7 +56,7 @@
     assert(r->second == 4);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_multimap<double, int> >();
 #if TEST_STD_VER >= 11
@@ -79,4 +79,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp
@@ -28,7 +28,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<double, int> C;
@@ -173,4 +173,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -117,4 +117,6 @@
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type.pass.cpp
@@ -67,10 +67,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_multimap<int, int> m;
     test(m);
     std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_node_type_hint.pass.cpp
@@ -53,10 +53,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_multimap<int, int> m;
     test(m);
     std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
@@ -118,4 +118,6 @@
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp
@@ -24,7 +24,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multimap<double, int> C;
@@ -152,4 +152,6 @@
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
@@ -49,7 +49,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_multimap<int, int> src{{1, 0}, {3, 0}, {5, 0}};
@@ -153,4 +153,5 @@
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp
@@ -21,7 +21,7 @@
 #include <unordered_map>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -40,4 +40,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_noexcept.pass.cpp
@@ -118,7 +118,7 @@
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<const MoveOnly, MoveOnly> V;
     {
@@ -187,4 +187,6 @@
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -579,4 +579,6 @@
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp
+++ test/std/containers/unord/unord.multiset/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <unordered_set>
 
-int main()
+int main(int, char**)
 {
     std::unordered_multiset<int, std::hash<int>, std::less<int>, std::allocator<long> > v;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/bucket.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/bucket.pass.cpp
+++ test/std/containers/unord/unord.multiset/bucket.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -73,4 +73,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
+++ test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -70,4 +70,6 @@
         assert(c.bucket_count() >= 8);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
+++ test/std/containers/unord/unord.multiset/bucket_size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -81,4 +81,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/clear.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/clear.pass.cpp
+++ test/std/containers/unord/unord.multiset/clear.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -59,4 +59,6 @@
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/count.pass.cpp
+++ test/std/containers/unord/unord.multiset/count.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -66,4 +66,6 @@
         assert(c.count(5) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
+++ test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -50,8 +50,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
+++ test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -46,8 +46,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
+++ test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
+++ test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -46,8 +46,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/emplace.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/emplace.pass.cpp
+++ test/std/containers/unord/unord.multiset/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<Emplaceable> C;
@@ -58,4 +58,6 @@
         assert(c.size() == 3);
         assert(*r == Emplaceable(5, 6));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
+++ test/std/containers/unord/unord.multiset/emplace_hint.pass.cpp
@@ -24,7 +24,7 @@
 #include "../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<Emplaceable> C;
@@ -61,4 +61,6 @@
         assert(c.size() == 3);
         assert(*r == Emplaceable(5, 6));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/empty.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/empty.fail.cpp
+++ test/std/containers/unord/unord.multiset/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::unordered_multiset<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/empty.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/empty.pass.cpp
+++ test/std/containers/unord/unord.multiset/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multiset<int> M;
@@ -42,4 +42,6 @@
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/eq.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/eq.pass.cpp
+++ test/std/containers/unord/unord.multiset/eq.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -176,4 +176,6 @@
         assert(!(c1 != c2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
+++ test/std/containers/unord/unord.multiset/equal_range_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -86,4 +86,6 @@
         assert(*r.first == 50);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
+++ test/std/containers/unord/unord.multiset/equal_range_non_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -86,4 +86,6 @@
         assert(*r.first == 50);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_const_iter.pass.cpp
@@ -28,7 +28,7 @@
 bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -96,4 +96,6 @@
             m.erase(it);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/erase_if.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_if.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_if.pass.cpp
@@ -79,7 +79,7 @@
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::unordered_multiset<int>>();
     test<std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>>> ();
@@ -87,4 +87,6 @@
 
     test<std::unordered_multiset<long>>();
     test<std::unordered_multiset<double>>();
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_iter_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -30,8 +30,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <exception>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -33,8 +33,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -31,8 +31,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.multiset/erase_key.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_key.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_key.pass.cpp
@@ -36,7 +36,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -172,4 +172,6 @@
     assert (only_deletions (m, m2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/erase_range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/erase_range.pass.cpp
+++ test/std/containers/unord/unord.multiset/erase_range.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -91,4 +91,6 @@
         assert(k == c.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp
+++ test/std/containers/unord/unord.multiset/extract_iterator.pass.cpp
@@ -36,7 +36,7 @@
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using set_type = std::unordered_multiset<int>;
@@ -56,4 +56,6 @@
         min_alloc_set m = {1, 2, 3, 4, 5, 6};
         test(m);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/extract_key.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/extract_key.pass.cpp
+++ test/std/containers/unord/unord.multiset/extract_key.pass.cpp
@@ -43,7 +43,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_multiset<int> m = {1, 2, 3, 4, 5, 6};
@@ -67,4 +67,6 @@
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/find_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/find_const.pass.cpp
+++ test/std/containers/unord/unord.multiset/find_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -64,4 +64,6 @@
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
+++ test/std/containers/unord/unord.multiset/find_non_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -64,4 +64,6 @@
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/incomplete.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/incomplete.pass.cpp
+++ test/std/containers/unord/unord.multiset/incomplete.pass.cpp
@@ -32,6 +32,8 @@
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
+++ test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp
@@ -46,7 +46,7 @@
     assert(*r == 5.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_multiset<double> >();
 #if TEST_STD_VER >= 11
@@ -56,4 +56,6 @@
         do_insert_const_lvalue_test<C>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp
+++ test/std/containers/unord/unord.multiset/insert_emplace_allocator_requirements.pass.cpp
@@ -18,8 +18,10 @@
 #include "container_test_types.h"
 #include "../../set_allocator_requirement_test_templates.h"
 
-int main()
+int main(int, char**)
 {
   testMultisetInsert<TCT::unordered_multiset<> >();
   testMultisetEmplace<TCT::unordered_multiset<> >();
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
+++ test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp
@@ -51,7 +51,7 @@
     assert(*r == 5.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_multiset<double> >();
 #if TEST_STD_VER >= 11
@@ -74,4 +74,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
+++ test/std/containers/unord/unord.multiset/insert_hint_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<double> C;
@@ -115,4 +115,6 @@
         assert(*r == 5);
     }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/insert_init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/insert_init.pass.cpp
+++ test/std/containers/unord/unord.multiset/insert_init.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -65,4 +65,6 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp
+++ test/std/containers/unord/unord.multiset/insert_node_type.pass.cpp
@@ -66,10 +66,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_multiset<int> m;
     test(m);
     std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp
+++ test/std/containers/unord/unord.multiset/insert_node_type_hint.pass.cpp
@@ -49,10 +49,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_multiset<int> m;
     test(m);
     std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/insert_range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/insert_range.pass.cpp
+++ test/std/containers/unord/unord.multiset/insert_range.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -66,4 +66,6 @@
         assert(c.count(4) == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
+++ test/std/containers/unord/unord.multiset/insert_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<double> C;
@@ -111,4 +111,6 @@
         assert(*r == 5);
     }
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/iterators.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/iterators.fail.cpp
+++ test/std/containers/unord/unord.multiset/iterators.fail.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -65,4 +65,6 @@
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/iterators.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/iterators.pass.cpp
+++ test/std/containers/unord/unord.multiset/iterators.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -125,4 +125,6 @@
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/load_factor.pass.cpp
+++ test/std/containers/unord/unord.multiset/load_factor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -71,4 +71,6 @@
         assert(c.load_factor() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
+++ test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -259,4 +259,6 @@
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
+++ test/std/containers/unord/unord.multiset/local_iterators.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -496,4 +496,6 @@
         assert(std::distance(i, j) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
+++ test/std/containers/unord/unord.multiset/max_bucket_count.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -34,4 +34,6 @@
         assert(c.max_bucket_count() > 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
+++ test/std/containers/unord/unord.multiset/max_load_factor.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -62,4 +62,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/max_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/max_size.pass.cpp
+++ test/std/containers/unord/unord.multiset/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -50,4 +50,6 @@
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/merge.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/merge.pass.cpp
+++ test/std/containers/unord/unord.multiset/merge.pass.cpp
@@ -49,7 +49,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_multiset<int> src{1, 3, 5};
@@ -150,4 +150,5 @@
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
Index: test/std/containers/unord/unord.multiset/rehash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/rehash.pass.cpp
+++ test/std/containers/unord/unord.multiset/rehash.pass.cpp
@@ -36,7 +36,7 @@
     assert(c.count(4) == 1);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -99,4 +99,6 @@
         test(c);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/reserve.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/reserve.pass.cpp
+++ test/std/containers/unord/unord.multiset/reserve.pass.cpp
@@ -45,7 +45,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int> C;
@@ -103,4 +103,6 @@
     }
 #endif
     reserve_invariant(20);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/scary.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/scary.pass.cpp
+++ test/std/containers/unord/unord.multiset/scary.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <unordered_set>
 
-int main()
+int main(int, char**)
 {
     typedef std::unordered_set<int> M1;
     typedef std::unordered_multiset<int> M2;
     M2::iterator i;
     M1::iterator j = i;
     ((void)j);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/size.pass.cpp
+++ test/std/containers/unord/unord.multiset/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_multiset<int> M;
@@ -58,4 +58,6 @@
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/swap_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/swap_member.pass.cpp
+++ test/std/containers/unord/unord.multiset/swap_member.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -566,4 +566,6 @@
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/types.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/types.pass.cpp
+++ test/std/containers/unord/unord.multiset/types.pass.cpp
@@ -31,7 +31,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<short> C;
@@ -65,4 +65,6 @@
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -106,4 +106,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -209,4 +209,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -93,4 +93,6 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -263,4 +263,6 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_multiset<int, std::hash<int>, Comp<int> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -168,4 +168,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -122,4 +122,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -104,4 +104,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp
@@ -44,7 +44,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -71,4 +71,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp
@@ -37,7 +37,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<MoveOnly> C;
@@ -64,4 +64,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_multiset<int, Hash<int> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -160,4 +160,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif // TEST_STD_VER > 11
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -94,4 +94,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -97,4 +97,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -99,4 +99,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -101,4 +101,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -171,4 +171,6 @@
         assert(s2.size() == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int P;
@@ -202,4 +202,6 @@
 
         assert(c0.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp
@@ -43,7 +43,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<MoveOnly> C;
@@ -70,4 +70,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp
@@ -40,7 +40,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -67,4 +67,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -166,4 +166,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -100,4 +100,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -103,4 +103,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -105,4 +105,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<int,
@@ -108,4 +108,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -62,4 +62,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -62,4 +62,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -66,4 +66,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -68,4 +68,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<NotConstructible,
@@ -70,4 +70,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp
@@ -21,7 +21,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -39,4 +39,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp
@@ -118,7 +118,7 @@
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_multiset<MoveOnly> C;
@@ -186,4 +186,6 @@
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -566,4 +566,6 @@
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp
===================================================================
--- test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp
+++ test/std/containers/unord/unord.set/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <unordered_set>
 
-int main()
+int main(int, char**)
 {
     std::unordered_set<int, std::hash<int>, std::less<int>, std::allocator<long> > v;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/bucket.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/bucket.pass.cpp
+++ test/std/containers/unord/unord.set/bucket.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -72,4 +72,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/bucket_count.pass.cpp
+++ test/std/containers/unord/unord.set/bucket_count.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -68,4 +68,6 @@
         assert(c.bucket_count() >= 8);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/bucket_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/bucket_size.pass.cpp
+++ test/std/containers/unord/unord.set/bucket_size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -76,4 +76,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/clear.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/clear.pass.cpp
+++ test/std/containers/unord/unord.set/clear.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -58,4 +58,6 @@
         assert(c.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/count.pass.cpp
+++ test/std/containers/unord/unord.set/count.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -65,4 +65,6 @@
         assert(c.count(5) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
+++ test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -50,8 +50,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
+++ test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -46,8 +46,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
+++ test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -49,8 +49,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
+++ test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef int T;
@@ -46,8 +46,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/emplace.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/emplace.pass.cpp
+++ test/std/containers/unord/unord.set/emplace.pass.cpp
@@ -23,7 +23,7 @@
 #include "../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<Emplaceable> C;
@@ -64,4 +64,6 @@
         assert(*r.first == Emplaceable(5, 6));
         assert(!r.second);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/emplace_hint.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/emplace_hint.pass.cpp
+++ test/std/containers/unord/unord.set/emplace_hint.pass.cpp
@@ -24,7 +24,7 @@
 #include "../../Emplaceable.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<Emplaceable> C;
@@ -61,4 +61,6 @@
         assert(c.size() == 2);
         assert(*r == Emplaceable(5, 6));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/empty.fail.cpp
===================================================================
--- test/std/containers/unord/unord.set/empty.fail.cpp
+++ test/std/containers/unord/unord.set/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::unordered_set<int> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/empty.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/empty.pass.cpp
+++ test/std/containers/unord/unord.set/empty.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_set<int> M;
@@ -42,4 +42,6 @@
     assert(m.empty());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/eq.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/eq.pass.cpp
+++ test/std/containers/unord/unord.set/eq.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -155,4 +155,6 @@
         assert(!(c1 != c2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/equal_range_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/equal_range_const.pass.cpp
+++ test/std/containers/unord/unord.set/equal_range_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -77,4 +77,6 @@
         assert(*r.first == 50);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
+++ test/std/containers/unord/unord.set/equal_range_non_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -77,4 +77,6 @@
         assert(*r.first == 50);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
+++ test/std/containers/unord/unord.set/erase_const_iter.pass.cpp
@@ -28,7 +28,7 @@
 bool operator==(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 struct Hash { size_t operator() (const TemplateConstructor &) const { return 0; } };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -94,4 +94,6 @@
             m.erase(it);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/erase_if.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_if.pass.cpp
+++ test/std/containers/unord/unord.set/erase_if.pass.cpp
@@ -69,7 +69,7 @@
     test0<S>({1,2,3}, False, {1,2,3});
 }
 
-int main()
+int main(int, char**)
 {
     test<std::unordered_set<int>>();
     test<std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>>> ();
@@ -77,4 +77,6 @@
 
     test<std::unordered_set<long>>();
     test<std::unordered_set<double>>();
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp
+++ test/std/containers/unord/unord.set/erase_iter_db1.pass.cpp
@@ -17,7 +17,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -30,8 +30,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp
+++ test/std/containers/unord/unord.set/erase_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <cstdlib>
 #include <exception>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -33,8 +33,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp
+++ test/std/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp
+++ test/std/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp
+++ test/std/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -32,8 +32,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp
+++ test/std/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp
@@ -19,7 +19,7 @@
 #include <exception>
 #include <cstdlib>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
@@ -31,8 +31,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/containers/unord/unord.set/erase_key.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_key.pass.cpp
+++ test/std/containers/unord/unord.set/erase_key.pass.cpp
@@ -36,7 +36,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -171,4 +171,6 @@
     assert (only_deletions (m, m2));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/erase_range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/erase_range.pass.cpp
+++ test/std/containers/unord/unord.set/erase_range.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -90,4 +90,6 @@
         assert(k == c.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/extract_iterator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/extract_iterator.pass.cpp
+++ test/std/containers/unord/unord.set/extract_iterator.pass.cpp
@@ -36,7 +36,7 @@
     assert(c.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         using set_type = std::unordered_set<int>;
@@ -56,4 +56,6 @@
         min_alloc_set m = {1, 2, 3, 4, 5, 6};
         test(m);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/extract_key.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/extract_key.pass.cpp
+++ test/std/containers/unord/unord.set/extract_key.pass.cpp
@@ -43,7 +43,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_set<int> m = {1, 2, 3, 4, 5, 6};
@@ -67,4 +67,6 @@
         int keys[] = {1, 2, 3, 4, 5, 6};
         test(m, std::begin(keys), std::end(keys));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/find_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/find_const.pass.cpp
+++ test/std/containers/unord/unord.set/find_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -63,4 +63,6 @@
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/find_non_const.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/find_non_const.pass.cpp
+++ test/std/containers/unord/unord.set/find_non_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -63,4 +63,6 @@
         assert(i == c.cend());
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/incomplete.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/incomplete.pass.cpp
+++ test/std/containers/unord/unord.set/incomplete.pass.cpp
@@ -32,6 +32,8 @@
 
 inline bool operator==(A const& L, A const& R) { return &L == &R; }
 
-int main() {
+int main(int, char**) {
     A a;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
+++ test/std/containers/unord/unord.set/insert_and_emplace_allocator_requirements.pass.cpp
@@ -21,8 +21,10 @@
 #include "../../set_allocator_requirement_test_templates.h"
 
 
-int main()
+int main(int, char**)
 {
   testSetInsert<TCT::unordered_set<> >();
   testSetEmplace<TCT::unordered_set<> >();
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
+++ test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp
@@ -50,7 +50,7 @@
     assert(r.second);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_const_lvalue_test<std::unordered_set<double> >();
 #if TEST_STD_VER >= 11
@@ -60,4 +60,6 @@
         do_insert_const_lvalue_test<C>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
+++ test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
@@ -51,7 +51,7 @@
     assert(*r == 5.5);
 }
 
-int main()
+int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_set<double> >();
 #if TEST_STD_VER >= 11
@@ -74,4 +74,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
+++ test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<double> C;
@@ -115,4 +115,6 @@
         assert(*r == 5);
     }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/insert_init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/insert_init.pass.cpp
+++ test/std/containers/unord/unord.set/insert_init.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -65,4 +65,6 @@
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/insert_node_type.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/insert_node_type.pass.cpp
+++ test/std/containers/unord/unord.set/insert_node_type.pass.cpp
@@ -73,10 +73,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_set<int> m;
     test(m);
     std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp
+++ test/std/containers/unord/unord.set/insert_node_type_hint.pass.cpp
@@ -51,10 +51,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     std::unordered_set<int> m;
     test(m);
     std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> m2;
     test(m2);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/insert_range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/insert_range.pass.cpp
+++ test/std/containers/unord/unord.set/insert_range.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_iterators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -66,4 +66,6 @@
         assert(c.count(4) == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
+++ test/std/containers/unord/unord.set/insert_rvalue.pass.cpp
@@ -21,7 +21,7 @@
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<double> C;
@@ -127,4 +127,6 @@
         assert(r.second);
     }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/iterators.fail.cpp
===================================================================
--- test/std/containers/unord/unord.set/iterators.fail.cpp
+++ test/std/containers/unord/unord.set/iterators.fail.cpp
@@ -22,7 +22,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -63,4 +63,6 @@
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/iterators.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/iterators.pass.cpp
+++ test/std/containers/unord/unord.set/iterators.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -125,4 +125,6 @@
         assert (!(cii != ii1 ));
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/load_factor.pass.cpp
+++ test/std/containers/unord/unord.set/load_factor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -71,4 +71,6 @@
         assert(c.load_factor() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/local_iterators.fail.cpp
===================================================================
--- test/std/containers/unord/unord.set/local_iterators.fail.cpp
+++ test/std/containers/unord/unord.set/local_iterators.fail.cpp
@@ -22,7 +22,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -257,4 +257,6 @@
         j = c.cend(b);
         assert(std::distance(i, j) == 0);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/local_iterators.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/local_iterators.pass.cpp
+++ test/std/containers/unord/unord.set/local_iterators.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -384,4 +384,6 @@
         assert(*i == 4);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
+++ test/std/containers/unord/unord.set/max_bucket_count.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -34,4 +34,6 @@
         assert(c.max_bucket_count() > 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/max_load_factor.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/max_load_factor.pass.cpp
+++ test/std/containers/unord/unord.set/max_load_factor.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -62,4 +62,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/max_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/max_size.pass.cpp
+++ test/std/containers/unord/unord.set/max_size.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
       typedef limited_allocator<int, 10> A;
@@ -46,4 +46,6 @@
       assert(c.max_size() <= max_dist);
       assert(c.max_size() <= alloc_max_size(c.get_allocator()));
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/merge.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/merge.pass.cpp
+++ test/std/containers/unord/unord.set/merge.pass.cpp
@@ -49,7 +49,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::unordered_set<int> src{1, 3, 5};
@@ -150,4 +150,5 @@
             first.merge(std::move(second));
         }
     }
+    return 0;
 }
Index: test/std/containers/unord/unord.set/rehash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/rehash.pass.cpp
+++ test/std/containers/unord/unord.set/rehash.pass.cpp
@@ -36,7 +36,7 @@
     assert(c.count(4) == 1);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -99,4 +99,6 @@
         test(c);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/reserve.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/reserve.pass.cpp
+++ test/std/containers/unord/unord.set/reserve.pass.cpp
@@ -45,7 +45,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int> C;
@@ -103,4 +103,6 @@
     }
 #endif
     reserve_invariant(20);
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/size.pass.cpp
+++ test/std/containers/unord/unord.set/size.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unordered_set<int> M;
@@ -58,4 +58,6 @@
     assert(m.size() == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/swap_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/swap_member.pass.cpp
+++ test/std/containers/unord/unord.set/swap_member.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -566,4 +566,6 @@
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/types.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/types.pass.cpp
+++ test/std/containers/unord/unord.set/types.pass.cpp
@@ -31,7 +31,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<short> C;
@@ -65,4 +65,6 @@
         static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -106,4 +106,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -184,4 +184,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -93,4 +93,6 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_allocator<int> A;
@@ -210,4 +210,6 @@
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_set<int, std::hash<int>, Comp<int> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -144,4 +144,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -106,4 +106,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -104,4 +104,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp
@@ -44,7 +44,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -71,4 +71,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp
@@ -37,7 +37,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<MoveOnly> C;
@@ -64,4 +64,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
@@ -23,6 +23,8 @@
     };
 
 
-int main() {
+int main(int, char**) {
     std::unordered_set<int, Hash<int> > m;
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
   {
         typedef std::unordered_set<int,
@@ -160,4 +160,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -94,4 +94,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -97,4 +97,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -99,4 +99,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -101,4 +101,6 @@
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -171,4 +171,6 @@
         assert(s2.size() == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int P;
@@ -152,4 +152,6 @@
 
         assert(c0.empty());
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp
@@ -43,7 +43,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<MoveOnly> C;
@@ -70,4 +70,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp
@@ -40,7 +40,7 @@
     std::size_t operator()(T const&) const;
 };
 
-int main()
+int main(int, char**)
 {
 #if defined(_LIBCPP_VERSION)
     {
@@ -67,4 +67,6 @@
                                                          some_comp<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -167,4 +167,6 @@
 
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -100,4 +100,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -103,4 +103,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -105,4 +105,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<int,
@@ -108,4 +108,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
@@ -23,7 +23,7 @@
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -42,4 +42,6 @@
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
     }
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -62,4 +62,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -66,4 +66,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -68,4 +68,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<NotConstructible,
@@ -70,4 +70,6 @@
         assert(c.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp
@@ -21,7 +21,7 @@
 #include <unordered_set>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if _LIBCPP_DEBUG >= 1
     {
@@ -39,4 +39,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp
@@ -118,7 +118,7 @@
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unordered_set<MoveOnly> C;
@@ -186,4 +186,6 @@
     }
 #endif // _LIBCPP_VERSION
 #endif
+
+  return 0;
 }
Index: test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef test_hash<std::hash<int> > Hash;
@@ -566,4 +566,6 @@
         assert(c2.max_load_factor() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/array.fail.cpp
===================================================================
--- test/std/containers/views/span.cons/array.fail.cpp
+++ test/std/containers/views/span.cons/array.fail.cpp
@@ -34,7 +34,7 @@
       volatile int  varr[] = {7,8,9};
 const volatile int cvarr[] = {1,3,5};
 
-int main ()
+int main(int, char**)
 {
 //  Size wrong
     {
@@ -68,4 +68,6 @@
     std::span<      volatile int,3> s6{ carr};  // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     std::span<      volatile int,3> s7{cvarr};  // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     }
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/array.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/array.pass.cpp
+++ test/std/containers/views/span.cons/array.pass.cpp
@@ -105,7 +105,7 @@
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -119,4 +119,6 @@
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/assign.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/assign.pass.cpp
+++ test/std/containers/views/span.cons/assign.pass.cpp
@@ -37,7 +37,7 @@
 std::string strs[] = {"ABC", "DEF", "GHI"};
 
 
-int main ()
+int main(int, char**)
 {
 
 //  constexpr dynamically sized assignment
@@ -289,4 +289,6 @@
             for (size_t j = i; j < std::size(spans); ++j)
                 assert((doAssign(spans[i], spans[j])));
     }
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/container.fail.cpp
===================================================================
--- test/std/containers/views/span.cons/container.fail.cpp
+++ test/std/containers/views/span.cons/container.fail.cpp
@@ -63,7 +63,7 @@
 };
 
 
-int main ()
+int main(int, char**)
 {
 
 //  Making non-const spans from const sources (a temporary binds to `const &`)
@@ -129,4 +129,6 @@
     std::span<      volatile int,1> s7{cv}; // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 1>'}}
     }
 
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/container.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/container.pass.cpp
+++ test/std/containers/views/span.cons/container.pass.cpp
@@ -117,7 +117,7 @@
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -131,4 +131,6 @@
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/copy.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/copy.pass.cpp
+++ test/std/containers/views/span.cons/copy.pass.cpp
@@ -42,7 +42,7 @@
 }
 
 
-int main ()
+int main(int, char**)
 {
     constexpr int carr[] = {1,2,3};
 
@@ -67,4 +67,6 @@
     testCV<const          int>();
     testCV<      volatile int>();
     testCV<const volatile int>();
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/deduct.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/deduct.pass.cpp
+++ test/std/containers/views/span.cons/deduct.pass.cpp
@@ -40,7 +40,7 @@
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
-int main ()
+int main(int, char**)
 {
     {
     int arr[] = {1,2,3};
@@ -83,4 +83,6 @@
     assert((size_t)s.size() == str.size());
     assert((std::equal(s.begin(), s.end(), std::begin(s), std::end(s))));
     }
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/default.fail.cpp
===================================================================
--- test/std/containers/views/span.cons/default.fail.cpp
+++ test/std/containers/views/span.cons/default.fail.cpp
@@ -22,10 +22,12 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::span<int, 2> s; // expected-error-re@span:* {{static_assert failed{{( due to requirement '2[LL]{0,2} == 0')?}} "Can't default construct a statically sized span with size > 0"}}
 
 //  TODO: This is what I want:
 // eXpected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/default.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/default.pass.cpp
+++ test/std/containers/views/span.cons/default.pass.cpp
@@ -64,7 +64,7 @@
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -78,4 +78,6 @@
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/ptr_len.fail.cpp
===================================================================
--- test/std/containers/views/span.cons/ptr_len.fail.cpp
+++ test/std/containers/views/span.cons/ptr_len.fail.cpp
@@ -27,7 +27,7 @@
       volatile int  varr[] = {7,8,9};
 const volatile int cvarr[] = {1,3,5};
 
-int main ()
+int main(int, char**)
 {
 //  We can't check that the size doesn't match - because that's a runtime property
 //  std::span<int, 2>   s1(arr, 3);
@@ -59,4 +59,6 @@
     std::span<      volatile int,3> s6{ carr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     std::span<      volatile int,3> s7{cvarr, 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     }
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/ptr_len.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/ptr_len.pass.cpp
+++ test/std/containers/views/span.cons/ptr_len.pass.cpp
@@ -95,7 +95,7 @@
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -109,4 +109,6 @@
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/ptr_ptr.fail.cpp
===================================================================
--- test/std/containers/views/span.cons/ptr_ptr.fail.cpp
+++ test/std/containers/views/span.cons/ptr_ptr.fail.cpp
@@ -27,7 +27,7 @@
       volatile int  varr[] = {7,8,9};
 const volatile int cvarr[] = {1,3,5};
 
-int main ()
+int main(int, char**)
 {
 //  We can't check that the size doesn't match - because that's a runtime property
 //  std::span<int, 2>   s1(arr, arr + 3);
@@ -59,4 +59,6 @@
     std::span<      volatile int,3> s6{ carr,  carr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     std::span<      volatile int,3> s7{cvarr, cvarr + 3};   // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
     }
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/ptr_ptr.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/ptr_ptr.pass.cpp
+++ test/std/containers/views/span.cons/ptr_ptr.pass.cpp
@@ -95,7 +95,7 @@
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -109,4 +109,6 @@
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/span.fail.cpp
===================================================================
--- test/std/containers/views/span.cons/span.fail.cpp
+++ test/std/containers/views/span.cons/span.fail.cpp
@@ -89,7 +89,7 @@
     }
 }
 
-int main ()
+int main(int, char**)
 {
     std::span<int>      sp;
     std::span<int, 0>   sp0;
@@ -100,4 +100,6 @@
     std::span<float, 0> s4{sp0};    // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
 
     checkCV();
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/span.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/span.pass.cpp
+++ test/std/containers/views/span.cons/span.pass.cpp
@@ -121,7 +121,7 @@
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -138,4 +138,6 @@
 //  assert((testConversionSpan<unsigned char, char>()));
 
     checkCV();
+
+  return 0;
 }
Index: test/std/containers/views/span.cons/stdarray.pass.cpp
===================================================================
--- test/std/containers/views/span.cons/stdarray.pass.cpp
+++ test/std/containers/views/span.cons/stdarray.pass.cpp
@@ -96,7 +96,7 @@
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan<int>(),    "");
     static_assert(testConstexprSpan<long>(),   "");
@@ -110,4 +110,6 @@
     testRuntimeSpan<A>();
 
     checkCV();
+
+  return 0;
 }
Index: test/std/containers/views/span.elem/data.pass.cpp
===================================================================
--- test/std/containers/views/span.elem/data.pass.cpp
+++ test/std/containers/views/span.elem/data.pass.cpp
@@ -40,7 +40,7 @@
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
 
 //  dynamic size
@@ -117,4 +117,6 @@
     testRuntimeSpan(std::span<std::string>(&s, 1), &s);
     testRuntimeSpan(std::span<std::string, 1>(&s, 1), &s);
 
+
+  return 0;
 }
Index: test/std/containers/views/span.elem/op_idx.pass.cpp
===================================================================
--- test/std/containers/views/span.elem/op_idx.pass.cpp
+++ test/std/containers/views/span.elem/op_idx.pass.cpp
@@ -51,7 +51,7 @@
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<const int>(iArr1, 1), 0), "");
 
@@ -115,4 +115,6 @@
     std::string s;
     testRuntimeSpan(std::span<std::string>   (&s, 1), 0);
     testRuntimeSpan(std::span<std::string, 1>(&s, 1), 0);
+
+  return 0;
 }
Index: test/std/containers/views/span.iterators/begin.pass.cpp
===================================================================
--- test/std/containers/views/span.iterators/begin.pass.cpp
+++ test/std/containers/views/span.iterators/begin.pass.cpp
@@ -70,7 +70,7 @@
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
 
-int main()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>()),            "");
     static_assert(testConstexprSpan(std::span<long>()),           "");
@@ -112,4 +112,6 @@
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
Index: test/std/containers/views/span.iterators/end.pass.cpp
===================================================================
--- test/std/containers/views/span.iterators/end.pass.cpp
+++ test/std/containers/views/span.iterators/end.pass.cpp
@@ -78,7 +78,7 @@
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
 
-int main()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>()),            "");
     static_assert(testConstexprSpan(std::span<long>()),           "");
@@ -120,4 +120,6 @@
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
Index: test/std/containers/views/span.iterators/rbegin.pass.cpp
===================================================================
--- test/std/containers/views/span.iterators/rbegin.pass.cpp
+++ test/std/containers/views/span.iterators/rbegin.pass.cpp
@@ -71,7 +71,7 @@
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
 
-int main()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>()),            "");
     static_assert(testConstexprSpan(std::span<long>()),           "");
@@ -113,4 +113,6 @@
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, static_cast<std::ptrdiff_t>(0)));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
Index: test/std/containers/views/span.iterators/rend.pass.cpp
===================================================================
--- test/std/containers/views/span.iterators/rend.pass.cpp
+++ test/std/containers/views/span.iterators/rend.pass.cpp
@@ -72,7 +72,7 @@
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
 
-int main()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>()),            "");
     static_assert(testConstexprSpan(std::span<long>()),           "");
@@ -114,4 +114,6 @@
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
Index: test/std/containers/views/span.objectrep/as_bytes.pass.cpp
===================================================================
--- test/std/containers/views/span.objectrep/as_bytes.pass.cpp
+++ test/std/containers/views/span.objectrep/as_bytes.pass.cpp
@@ -45,7 +45,7 @@
 struct A{};
 int iArr2[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
 
-int main ()
+int main(int, char**)
 {
     testRuntimeSpan(std::span<int>        ());
     testRuntimeSpan(std::span<long>       ());
@@ -74,4 +74,6 @@
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
Index: test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp
===================================================================
--- test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp
+++ test/std/containers/views/span.objectrep/as_writeable_bytes.fail.cpp
@@ -28,7 +28,7 @@
 
 struct A {};
 
-int main ()
+int main(int, char**)
 {
     std::as_writeable_bytes(std::span<const int>());            // expected-error {{no matching function for call to 'as_writeable_bytes'}}
     std::as_writeable_bytes(std::span<const long>());           // expected-error {{no matching function for call to 'as_writeable_bytes'}}
@@ -44,4 +44,6 @@
 
     std::as_writeable_bytes(std::span<const int>   (iArr2, 1));     // expected-error {{no matching function for call to 'as_writeable_bytes'}}
     std::as_writeable_bytes(std::span<const int, 1>(iArr2 + 5, 1)); // expected-error {{no matching function for call to 'as_writeable_bytes'}}
+
+  return 0;
 }
Index: test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp
===================================================================
--- test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp
+++ test/std/containers/views/span.objectrep/as_writeable_bytes.pass.cpp
@@ -45,7 +45,7 @@
 struct A{};
 int iArr2[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
 
-int main ()
+int main(int, char**)
 {
     testRuntimeSpan(std::span<int>        ());
     testRuntimeSpan(std::span<long>       ());
@@ -74,4 +74,6 @@
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0));
     testRuntimeSpan(std::span<std::string>(&s, 1));
+
+  return 0;
 }
Index: test/std/containers/views/span.obs/empty.pass.cpp
===================================================================
--- test/std/containers/views/span.obs/empty.pass.cpp
+++ test/std/containers/views/span.obs/empty.pass.cpp
@@ -24,7 +24,7 @@
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
     static_assert( noexcept(std::span<int>   ().empty()), "");
     static_assert( noexcept(std::span<int, 0>().empty()), "");
@@ -69,4 +69,6 @@
     std::string s;
     assert( ((std::span<std::string>(&s, (std::ptrdiff_t) 0)).empty()));
     assert(!((std::span<std::string>(&s, 1).empty())));
+
+  return 0;
 }
Index: test/std/containers/views/span.obs/size.pass.cpp
===================================================================
--- test/std/containers/views/span.obs/size.pass.cpp
+++ test/std/containers/views/span.obs/size.pass.cpp
@@ -40,7 +40,7 @@
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>(), 0),            "");
     static_assert(testConstexprSpan(std::span<long>(), 0),           "");
@@ -87,4 +87,6 @@
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0), 0);
     testRuntimeSpan(std::span<std::string>(&s, 1), 1);
+
+  return 0;
 }
Index: test/std/containers/views/span.obs/size_bytes.pass.cpp
===================================================================
--- test/std/containers/views/span.obs/size_bytes.pass.cpp
+++ test/std/containers/views/span.obs/size_bytes.pass.cpp
@@ -41,7 +41,7 @@
 constexpr int iArr1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9};
           int iArr2[] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 
-int main ()
+int main(int, char**)
 {
     static_assert(testConstexprSpan(std::span<int>(), 0),            "");
     static_assert(testConstexprSpan(std::span<long>(), 0),           "");
@@ -88,4 +88,6 @@
     std::string s;
     testRuntimeSpan(std::span<std::string>(&s, (std::ptrdiff_t) 0), 0);
     testRuntimeSpan(std::span<std::string>(&s, 1), 1);
+
+  return 0;
 }
Index: test/std/containers/views/span.sub/first.pass.cpp
===================================================================
--- test/std/containers/views/span.sub/first.pass.cpp
+++ test/std/containers/views/span.sub/first.pass.cpp
@@ -68,7 +68,7 @@
           int   arr[] = {5,6,7};
 std::string   sarr [] = { "ABC", "DEF", "GHI", "JKL", "MNO"};
 
-int main ()
+int main(int, char**)
 {
     {
     using Sp = std::span<const int>;
@@ -132,4 +132,6 @@
     testRuntimeSpan<Sp, 4>(Sp{sarr});
     testRuntimeSpan<Sp, 5>(Sp{sarr});
     }
+
+  return 0;
 }
Index: test/std/containers/views/span.sub/last.pass.cpp
===================================================================
--- test/std/containers/views/span.sub/last.pass.cpp
+++ test/std/containers/views/span.sub/last.pass.cpp
@@ -68,7 +68,7 @@
           int   arr[] = {5,6,7};
 std::string   sarr [] = { "ABC", "DEF", "GHI", "JKL", "MNO"};
 
-int main ()
+int main(int, char**)
 {
     {
     using Sp = std::span<const int>;
@@ -132,4 +132,6 @@
     testRuntimeSpan<Sp, 4>(Sp{sarr});
     testRuntimeSpan<Sp, 5>(Sp{sarr});
     }
+
+  return 0;
 }
Index: test/std/containers/views/span.sub/subspan.pass.cpp
===================================================================
--- test/std/containers/views/span.sub/subspan.pass.cpp
+++ test/std/containers/views/span.sub/subspan.pass.cpp
@@ -106,7 +106,7 @@
 constexpr int carr1[] = {1,2,3,4};
           int  arr1[] = {5,6,7};
 
-int main ()
+int main(int, char**)
 {
     {
     using Sp = std::span<const int>;
@@ -206,4 +206,6 @@
     testRuntimeSpan<Sp, 2>(Sp{arr1});
     testRuntimeSpan<Sp, 3>(Sp{arr1});
     }
+
+  return 0;
 }
Index: test/std/containers/views/types.pass.cpp
===================================================================
--- test/std/containers/views/types.pass.cpp
+++ test/std/containers/views/types.pass.cpp
@@ -96,11 +96,13 @@
 
 struct A{};
 
-int main ()
+int main(int, char**)
 {
     test<int>();
     test<long>();
     test<double>();
     test<std::string>();
     test<A>();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.fail.cpp
@@ -37,7 +37,9 @@
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.pass.cpp
@@ -39,7 +39,9 @@
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.fail.cpp
@@ -33,7 +33,9 @@
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.pass.cpp
@@ -35,7 +35,9 @@
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.cpp
@@ -40,7 +40,9 @@
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.pass.cpp
@@ -42,7 +42,9 @@
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.cpp
@@ -31,7 +31,9 @@
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.pass.cpp
@@ -33,7 +33,9 @@
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.cpp
@@ -33,7 +33,9 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.pass.cpp
@@ -35,7 +35,9 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.pass.cpp
@@ -35,7 +35,9 @@
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.pass.cpp
@@ -34,7 +34,9 @@
     assert(B::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.pass.cpp
@@ -31,7 +31,9 @@
     std::auto_ptr<A> ap2(source());
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.pass.cpp
@@ -32,7 +32,9 @@
     delete p1;
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.pass.cpp
@@ -32,7 +32,9 @@
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.pass.cpp
@@ -32,7 +32,9 @@
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.pass.cpp
@@ -33,7 +33,9 @@
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.pass.cpp
@@ -49,7 +49,9 @@
     assert(A::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp
+++ test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp
@@ -30,9 +30,11 @@
     ((void)p);
 }
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<double>();
     test<void>();
+
+  return 0;
 }
Index: test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp
===================================================================
--- test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp
+++ test/std/depr/depr.auto.ptr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/assert_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/assert_h.pass.cpp
+++ test/std/depr/depr.c.headers/assert_h.pass.cpp
@@ -14,6 +14,8 @@
 #error assert not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/ciso646.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/ciso646.pass.cpp
+++ test/std/depr/depr.c.headers/ciso646.pass.cpp
@@ -10,6 +10,8 @@
 
 #include <ciso646>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/complex.h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/complex.h.pass.cpp
+++ test/std/depr/depr.c.headers/complex.h.pass.cpp
@@ -10,8 +10,10 @@
 
 #include <complex.h>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> d;
     (void)d;
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/ctype_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/ctype_h.pass.cpp
+++ test/std/depr/depr.c.headers/ctype_h.pass.cpp
@@ -68,7 +68,7 @@
 #error toupper defined
 #endif
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<decltype(isalnum(0)), int>::value), "");
     static_assert((std::is_same<decltype(isalpha(0)), int>::value), "");
@@ -99,4 +99,6 @@
     assert(isxdigit('a'));
     assert(tolower('A') == 'a');
     assert(toupper('a') == 'A');
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/errno_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/errno_h.pass.cpp
+++ test/std/depr/depr.c.headers/errno_h.pass.cpp
@@ -27,6 +27,8 @@
 #error errno not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/fenv_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/fenv_h.pass.cpp
+++ test/std/depr/depr.c.headers/fenv_h.pass.cpp
@@ -57,7 +57,7 @@
 #error FE_DFL_ENV not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     fenv_t fenv = {};
     fexcept_t fex = 0;
@@ -72,4 +72,6 @@
     static_assert((std::is_same<decltype(feholdexcept(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(fesetenv(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(feupdateenv(&fenv)), int>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/float_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/float_h.pass.cpp
+++ test/std/depr/depr.c.headers/float_h.pass.cpp
@@ -178,6 +178,8 @@
 #endif
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/inttypes_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/inttypes_h.pass.cpp
+++ test/std/depr/depr.c.headers/inttypes_h.pass.cpp
@@ -877,7 +877,7 @@
     ((void)t); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test<int8_t >();
     test<int16_t>();
@@ -927,4 +927,6 @@
     static_assert((std::is_same<decltype(strtoumax("", (char**)0, 0)), uintmax_t>::value), "");
     static_assert((std::is_same<decltype(wcstoimax(L"", (wchar_t**)0, 0)), intmax_t>::value), "");
     static_assert((std::is_same<decltype(wcstoumax(L"", (wchar_t**)0, 0)), uintmax_t>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/iso646_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/iso646_h.pass.cpp
+++ test/std/depr/depr.c.headers/iso646_h.pass.cpp
@@ -10,7 +10,9 @@
 
 #include <iso646.h>
 
-int main()
+int main(int, char**)
 {
     // Nothing to test
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/limits_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/limits_h.pass.cpp
+++ test/std/depr/depr.c.headers/limits_h.pass.cpp
@@ -86,6 +86,8 @@
 #error ULLONG_MAX not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/locale_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/locale_h.pass.cpp
+++ test/std/depr/depr.c.headers/locale_h.pass.cpp
@@ -39,9 +39,11 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     lconv lc; ((void)lc);
     static_assert((std::is_same<decltype(setlocale(0, "")), char*>::value), "");
     static_assert((std::is_same<decltype(localeconv()), lconv*>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/math_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/math_h.pass.cpp
+++ test/std/depr/depr.c.headers/math_h.pass.cpp
@@ -1463,7 +1463,7 @@
     assert(trunc(1) == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test_abs();
     test_acos();
@@ -1535,4 +1535,6 @@
     test_scalbn();
     test_tgamma();
     test_trunc();
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/setjmp_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/setjmp_h.pass.cpp
+++ test/std/depr/depr.c.headers/setjmp_h.pass.cpp
@@ -15,10 +15,12 @@
 #error setjmp not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     jmp_buf jb;
     ((void)jb); // Prevent unused warning
     static_assert((std::is_same<decltype(longjmp(jb, 0)), void>::value),
                   "std::is_same<decltype(longjmp(jb, 0)), void>::value");
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/signal_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/signal_h.pass.cpp
+++ test/std/depr/depr.c.headers/signal_h.pass.cpp
@@ -47,10 +47,12 @@
 #error SIGTERM not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     sig_atomic_t sig; ((void)sig);
     typedef void (*func)(int);
     static_assert((std::is_same<decltype(signal(0, (func)0)), func>::value), "");
     static_assert((std::is_same<decltype(raise(0)), int>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/stdarg_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/stdarg_h.pass.cpp
+++ test/std/depr/depr.c.headers/stdarg_h.pass.cpp
@@ -30,8 +30,10 @@
 #error va_start not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     va_list va;
     ((void)va);
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/stdbool_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/stdbool_h.pass.cpp
+++ test/std/depr/depr.c.headers/stdbool_h.pass.cpp
@@ -26,6 +26,8 @@
 #error false should not be defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/stddef_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/stddef_h.pass.cpp
+++ test/std/depr/depr.c.headers/stddef_h.pass.cpp
@@ -22,7 +22,7 @@
 #error offsetof not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     void *p = NULL;
     assert(!p);
@@ -65,4 +65,6 @@
                   std::alignment_of<void*>::value,
                   "std::alignment_of<max_align_t>::value >= "
                   "std::alignment_of<void*>::value");
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/stdint_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/stdint_h.pass.cpp
+++ test/std/depr/depr.c.headers/stdint_h.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     // typedef int8_t
     static_assert(sizeof(int8_t)*CHAR_BIT == 8,
@@ -287,4 +287,6 @@
 #ifndef UINTMAX_C
 #error UINTMAX_C not defined
 #endif
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/stdio_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/stdio_h.pass.cpp
+++ test/std/depr/depr.c.headers/stdio_h.pass.cpp
@@ -103,7 +103,7 @@
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" // for tmpnam
 #endif
 
-int main()
+int main(int, char**)
 {
     FILE* fp = 0;
     fpos_t fpos = fpos_t();
@@ -165,4 +165,6 @@
     static_assert((std::is_same<decltype(feof(fp)), int>::value), "");
     static_assert((std::is_same<decltype(ferror(fp)), int>::value), "");
     static_assert((std::is_same<decltype(perror("")), void>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/stdlib_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/stdlib_h.pass.cpp
+++ test/std/depr/depr.c.headers/stdlib_h.pass.cpp
@@ -63,7 +63,7 @@
 #error RAND_MAX not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     size_t s = 0; ((void)s);
     div_t d; ((void)d);
@@ -116,4 +116,6 @@
     static_assert((std::is_same<decltype(wctomb(pc,L' ')), int>::value), "");
     static_assert((std::is_same<decltype(mbstowcs(pw,"",0)), size_t>::value), "");
     static_assert((std::is_same<decltype(wcstombs(pc,pwc,0)), size_t>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/string_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/string_h.pass.cpp
+++ test/std/depr/depr.c.headers/string_h.pass.cpp
@@ -15,7 +15,7 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     size_t s = 0;
     void* vp = 0;
@@ -57,4 +57,6 @@
     static_assert((std::is_same<decltype(strstr(cpc, cpc)), const char*>::value), "");
     static_assert((std::is_same<decltype(memchr(vpc, 0, s)), const void*>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/tgmath_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/tgmath_h.pass.cpp
+++ test/std/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -10,10 +10,12 @@
 
 #include <tgmath.h>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> cd;
     (void)cd;
     double x = sin(1.0);
     (void)x; // to placate scan-build
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/time_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/time_h.pass.cpp
+++ test/std/depr/depr.c.headers/time_h.pass.cpp
@@ -19,7 +19,7 @@
 #error CLOCKS_PER_SEC not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     clock_t c = 0; ((void)c);
     size_t s = 0;
@@ -36,4 +36,6 @@
     char* c1 = 0;
     const char* c2 = 0;
     static_assert((std::is_same<decltype(strftime(c1,s,c2,&tmv)), size_t>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/uchar_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/uchar_h.pass.cpp
+++ test/std/depr/depr.c.headers/uchar_h.pass.cpp
@@ -15,6 +15,8 @@
 
 #include <uchar.h>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/wchar_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/wchar_h.pass.cpp
+++ test/std/depr/depr.c.headers/wchar_h.pass.cpp
@@ -28,7 +28,7 @@
 #error WEOF not defined
 #endif
 
-int main()
+int main(int, char**)
 {
 // mbstate_t comes from the underlying C library; it is defined (in C99) as:
 //    a complete object type other than an array type that can hold the conversion
@@ -126,4 +126,6 @@
     static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), "");
     static_assert((std::is_same<decltype(wprintf(L"")), int>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/depr/depr.c.headers/wctype_h.pass.cpp
===================================================================
--- test/std/depr/depr.c.headers/wctype_h.pass.cpp
+++ test/std/depr/depr.c.headers/wctype_h.pass.cpp
@@ -87,7 +87,7 @@
 #error wctrans defined
 #endif
 
-int main()
+int main(int, char**)
 {
     wint_t w = 0;
     wctrans_t wctr = 0;
@@ -110,4 +110,6 @@
     static_assert((std::is_same<decltype(towupper(w)), wint_t>::value), "");
     static_assert((std::is_same<decltype(towctrans(w, wctr)), wint_t>::value), "");
     static_assert((std::is_same<decltype(wctrans("")), wctrans_t>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.cpp
@@ -18,7 +18,9 @@
 
 double binary_f(int i, short j) {return i - j + .75;}
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_binary_function<int, short, double> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.pass.cpp
@@ -17,10 +17,12 @@
 
 double binary_f(int i, short j) {return i - j + .75;}
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_binary_function<int, short, double> F;
     static_assert((std::is_base_of<std::binary_function<int, short, double>, F>::value), "");
     const F f(binary_f);
     assert(f(36, 27) == 9.75);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.cpp
@@ -18,7 +18,9 @@
 
 double unary_f(int i) {return 0.5 - i;}
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, double> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.pass.cpp
@@ -17,10 +17,12 @@
 
 double unary_f(int i) {return 0.5 - i;}
 
-int main()
+int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, double> F;
     static_assert((std::is_base_of<std::unary_function<int, double>, F>::value), "");
     const F f(unary_f);
     assert(f(36) == -35.5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.cpp
@@ -21,7 +21,9 @@
 
 double unary_f(int i) {return 0.5 - i;}
 
-int main()
+int main(int, char**)
 {
     assert(std::ptr_fun(unary_f)(36) == -35.5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
@@ -19,7 +19,9 @@
 
 double unary_f(int i) {return 0.5 - i;}
 
-int main()
+int main(int, char**)
 {
     assert(std::ptr_fun(unary_f)(36) == -35.5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.cpp
@@ -21,7 +21,9 @@
 
 double binary_f(int i, short j) {return i - j + .75;}
 
-int main()
+int main(int, char**)
 {
     assert(std::ptr_fun(binary_f)(36, 27) == 9.75);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
@@ -19,7 +19,9 @@
 
 double binary_f(int i, short j) {return i - j + .75;}
 
-int main()
+int main(int, char**)
 {
     assert(std::ptr_fun(binary_f)(36, 27) == 9.75);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
@@ -27,8 +27,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun(&A::a3)(&a) == 1);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.pass.cpp
@@ -24,8 +24,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun(&A::a3)(&a) == 1);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
@@ -27,8 +27,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun(&A::a4)(&a, 6) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
@@ -24,8 +24,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun(&A::a4)(&a, 6) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun1_ref_t<double, A, unsigned> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp
@@ -23,11 +23,13 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun1_ref_t<double, A, unsigned> F;
     static_assert((std::is_base_of<std::binary_function<A, unsigned, double>, F>::value), "");
     const F f(&A::a4);
     const A a = A();
     assert(f(a, 6) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun1_t<double, A, unsigned> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.pass.cpp
@@ -23,11 +23,13 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun1_t<double, A, unsigned> F;
     static_assert((std::is_base_of<std::binary_function<const A*, unsigned, double>, F>::value), "");
     const F f(&A::a4);
     const A a = A();
     assert(f(&a, 6) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
@@ -27,8 +27,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun_ref(&A::a3)(a) == 1);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.pass.cpp
@@ -24,8 +24,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun_ref(&A::a3)(a) == 1);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
@@ -27,8 +27,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun_ref(&A::a4)(a, 6) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
@@ -24,8 +24,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     const A a = A();
     assert(std::mem_fun_ref(&A::a4)(a, 6) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun_ref_t<int, A> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp
@@ -23,11 +23,13 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun_ref_t<int, A> F;
     static_assert((std::is_base_of<std::unary_function<A, int>, F>::value), "");
     const F f(&A::a3);
     const A a = A();
     assert(f(a) == 1);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun_t<int, A> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.pass.cpp
@@ -23,11 +23,13 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::const_mem_fun_t<int, A> F;
     static_assert((std::is_base_of<std::unary_function<const A*, int>, F>::value), "");
     const F f(&A::a3);
     const A a = A();
     assert(f(&a) == 1);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
@@ -27,8 +27,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun(&A::a1)(&a) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.pass.cpp
@@ -24,8 +24,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun(&A::a1)(&a) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
@@ -27,8 +27,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun(&A::a2)(&a, 5) == 6);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
@@ -24,8 +24,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun(&A::a2)(&a, 5) == 6);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun1_ref_t<short, A, int> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.pass.cpp
@@ -23,11 +23,13 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun1_ref_t<short, A, int> F;
     static_assert((std::is_base_of<std::binary_function<A, int, short>, F>::value), "");
     const F f(&A::a2);
     A a;
     assert(f(a, 5) == 6);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun1_t<short, A, int> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.pass.cpp
@@ -23,11 +23,13 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun1_t<short, A, int> F;
     static_assert((std::is_base_of<std::binary_function<A*, int, short>, F>::value), "");
     const F f(&A::a2);
     A a;
     assert(f(&a, 5) == 6);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
@@ -27,8 +27,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun_ref(&A::a1)(a) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.pass.cpp
@@ -24,8 +24,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun_ref(&A::a1)(a) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
@@ -27,8 +27,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun_ref(&A::a2)(a, 5) == 6);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
@@ -24,8 +24,10 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     A a;
     assert(std::mem_fun_ref(&A::a2)(a, 5) == 6);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun_ref_t<char, A> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.pass.cpp
@@ -23,11 +23,13 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun_ref_t<char, A> F;
     static_assert((std::is_base_of<std::unary_function<A, char>, F>::value), "");
     const F f(&A::a1);
     A a;
     assert(f(a) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
@@ -26,7 +26,9 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun_t<char, A> F;
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.pass.cpp
@@ -23,11 +23,13 @@
     double a4(unsigned i) const {return i-1;}
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::mem_fun_t<char, A> F;
     static_assert((std::is_base_of<std::unary_function<A*, char>, F>::value), "");
     const F f(&A::a1);
     A a;
     assert(f(&a) == 5);
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
+++ test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
@@ -21,9 +21,11 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::binary_function<int, unsigned, char>::first_argument_type, int>::value), "");
     static_assert((std::is_same<std::binary_function<int, unsigned, char>::second_argument_type, unsigned>::value), "");
     static_assert((std::is_same<std::binary_function<int, unsigned, char>::result_type, char>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
+++ test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
@@ -20,8 +20,10 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::unary_function<unsigned, char>::argument_type, unsigned>::value), "");
     static_assert((std::is_same<std::unary_function<unsigned, char>::result_type, char>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.function.objects/nothing_to_do.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/nothing_to_do.pass.cpp
+++ test/std/depr/depr.function.objects/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.ios.members/io_state.pass.cpp
===================================================================
--- test/std/depr/depr.ios.members/io_state.pass.cpp
+++ test/std/depr/depr.ios.members/io_state.pass.cpp
@@ -20,10 +20,12 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     std::strstream::io_state b = std::strstream::eofbit;
     assert(b == std::ios::eofbit);
 #endif
+
+  return 0;
 }
Index: test/std/depr/depr.ios.members/open_mode.pass.cpp
===================================================================
--- test/std/depr/depr.ios.members/open_mode.pass.cpp
+++ test/std/depr/depr.ios.members/open_mode.pass.cpp
@@ -20,10 +20,12 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     std::strstream::open_mode b = std::strstream::app;
     assert(b == std::ios::app);
 #endif
+
+  return 0;
 }
Index: test/std/depr/depr.ios.members/seek_dir.pass.cpp
===================================================================
--- test/std/depr/depr.ios.members/seek_dir.pass.cpp
+++ test/std/depr/depr.ios.members/seek_dir.pass.cpp
@@ -20,10 +20,12 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     std::strstream::seek_dir b = std::strstream::cur;
     assert(b == std::ios::cur);
 #endif
+
+  return 0;
 }
Index: test/std/depr/depr.ios.members/streamoff.pass.cpp
===================================================================
--- test/std/depr/depr.ios.members/streamoff.pass.cpp
+++ test/std/depr/depr.ios.members/streamoff.pass.cpp
@@ -20,10 +20,12 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     static_assert((std::is_integral<std::ios_base::streamoff>::value), "");
     static_assert((std::is_signed<std::ios_base::streamoff>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/depr/depr.ios.members/streampos.pass.cpp
===================================================================
--- test/std/depr/depr.ios.members/streampos.pass.cpp
+++ test/std/depr/depr.ios.members/streampos.pass.cpp
@@ -20,9 +20,11 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     static_assert((std::is_same<std::ios_base::streampos, std::streampos>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp
===================================================================
--- test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp
+++ test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp
@@ -24,7 +24,9 @@
 #include "../test_func.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::bind1st(test_func(1), 5); // expected-error{{'bind1st<test_func, int>' is deprecated}}
+
+  return 0;
 }
Index: test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp
===================================================================
--- test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp
+++ test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.pass.cpp
@@ -18,7 +18,9 @@
 
 #include "../test_func.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::bind1st(test_func(1), 5)(10.) == -5.);
+
+  return 0;
 }
Index: test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp
===================================================================
--- test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp
+++ test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp
@@ -24,7 +24,9 @@
 #include "../test_func.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::bind2nd(test_func(1), 5); // expected-error{{'bind2nd<test_func, int>' is deprecated}}
+
+  return 0;
 }
Index: test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp
===================================================================
--- test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp
+++ test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.pass.cpp
@@ -18,7 +18,9 @@
 
 #include "../test_func.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::bind2nd(test_func(1), 5)(10) == 5.);
+
+  return 0;
 }
Index: test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp
===================================================================
--- test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp
+++ test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp
@@ -24,7 +24,9 @@
 #include "../test_func.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::binder1st<test_func> B1ST; // expected-error{{'binder1st<test_func>' is deprecated}}
+
+  return 0;
 }
Index: test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp
===================================================================
--- test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp
+++ test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp
@@ -51,8 +51,10 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     t.do_test();
+
+  return 0;
 }
Index: test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp
===================================================================
--- test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp
+++ test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp
@@ -24,7 +24,9 @@
 #include "../test_func.h"
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::binder2nd<test_func> B2ND; // expected-error{{'binder2nd<test_func>' is deprecated}}
+
+  return 0;
 }
Index: test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp
===================================================================
--- test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp
+++ test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp
@@ -51,8 +51,10 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     t.do_test();
+
+  return 0;
 }
Index: test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp
===================================================================
--- test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp
+++ test/std/depr/depr.lib.binders/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123 4.5 dog";
@@ -40,4 +40,6 @@
         assert(buf[9] == 'o');
         assert(buf[10] == 'g');
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/ccp_size.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123 4.5 dog";
@@ -40,4 +40,6 @@
         assert(buf[5] == '.');
         assert(buf[6] == '5');
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -40,4 +40,6 @@
         assert(buf[9] == 'g');
         assert(buf[10] == 'g');
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.cons/cp_size.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -40,4 +40,6 @@
         assert(buf[5] == '5');
         assert(buf[6] == '5');
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/rdbuf.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123 4.5 dog";
@@ -23,4 +23,6 @@
         std::strstreambuf* sb = in.rdbuf();
         assert(sb->sgetc() == '1');
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.istrstream/depr.istrstream.members/str.pass.cpp
@@ -15,11 +15,13 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123 4.5 dog";
         std::istrstream in(buf);
         assert(in.str() == std::string("123 4.5 dog"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.istrstream/types.pass.cpp
@@ -16,7 +16,9 @@
 #include <strstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::istream, std::istrstream>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/cp_size_mode.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -38,4 +38,6 @@
         out << i << ' ' << d << ' ' << s << std::ends;
         assert(out.str() == std::string("123 4.5 dog321 5.5 cat"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     std::ostrstream out;
     int i = 123;
@@ -25,4 +25,6 @@
     out << i << ' ' << d << ' ' << s << std::ends;
     assert(out.str() == std::string("123 4.5 dog"));
     out.freeze(false);
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/freeze.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostrstream out;
@@ -30,4 +30,6 @@
         assert(out.str() == std::string("a"));
         out.freeze(false);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/pcount.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostrstream out;
@@ -23,4 +23,6 @@
         out << 123 << ' ' << 4.5 << ' ' << "dog";
         assert(out.pcount() == 11);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/rdbuf.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -24,4 +24,6 @@
         assert(sb->sputc('a') == 'a');
         assert(buf == std::string("a23 4.5 dog"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.ostrstream/depr.ostrstream.members/str.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostrstream out;
@@ -23,4 +23,6 @@
         assert(out.str() == std::string("123 4.5 dog"));
         out.freeze(false);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.ostrstream/types.pass.cpp
@@ -16,7 +16,9 @@
 #include <strstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::ostream, std::ostrstream>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/cp_size_mode.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -56,4 +56,6 @@
         inout << i << ' ' << d << ' ' << s;
         assert(inout.str() == std::string("123 4.5 dog321 5.5 cat"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.cons/default.pass.cpp
@@ -17,7 +17,7 @@
 #include <cstring>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     std::strstream inout;
     int i = 123;
@@ -33,4 +33,6 @@
     assert(d == 4.5);
     assert(std::strcmp(s.c_str(), "dog") == 0);
     inout.freeze(false);
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.dest/rdbuf.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "123 4.5 dog";
@@ -24,4 +24,6 @@
         assert(sb->sputc('a') == 'a');
         assert(buf == std::string("a23 4.5 dog"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/freeze.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstream out;
@@ -30,4 +30,6 @@
         assert(out.str() == std::string("a"));
         out.freeze(false);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/pcount.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstream out;
@@ -23,4 +23,6 @@
         out << 123 << ' ' << 4.5 << ' ' << "dog";
         assert(out.pcount() == 11);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstream/depr.strstream.oper/str.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstream out;
@@ -23,4 +23,6 @@
         assert(out.str() == std::string("123 4.5 dog"));
         out.freeze(false);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstream/types.pass.cpp
@@ -21,11 +21,13 @@
 #include <strstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::iostream, std::strstream>::value), "");
     static_assert((std::is_same<std::strstream::char_type, char>::value), "");
     static_assert((std::is_same<std::strstream::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::strstream::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::strstream::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ccp_size.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "abcd";
@@ -36,4 +36,6 @@
         assert(sb.snextc() == 'd');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cp_size_cp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstring>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "abcd";
@@ -93,4 +93,6 @@
         assert(sb.snextc() == 'j');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cscp_size.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const signed char buf[] = "abcd";
@@ -36,4 +36,6 @@
         assert(sb.snextc() == 'd');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/cucp_size.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         unsigned char buf[] = "abcd";
@@ -36,4 +36,6 @@
         assert(sb.snextc() == 'd');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/custom_alloc.pass.cpp
@@ -38,7 +38,7 @@
         {return std::strstreambuf::overflow(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test s(my_alloc, my_free);
@@ -47,4 +47,6 @@
         assert(called == 1);
     }
     assert(called == 2);
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstreambuf s;
@@ -27,4 +27,6 @@
         assert(s.str() == nullptr);
         assert(s.pcount() == 0);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/scp_size_scp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstring>
 
-int main()
+int main(int, char**)
 {
     {
         signed char buf[] = "abcd";
@@ -93,4 +93,6 @@
         assert(sb.snextc() == 'j');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/ucp_size_ucp.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstring>
 
-int main()
+int main(int, char**)
 {
     {
         unsigned char buf[] = "abcd";
@@ -93,4 +93,6 @@
         assert(sb.snextc() == 'j');
         assert(sb.snextc() == EOF);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/freeze.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstreambuf sb;
@@ -24,4 +24,6 @@
         sb.freeze(false);
         assert(sb.sputc('a') == 'a');
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/overflow.pass.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <strstream>
 
-int main() {
+int main(int, char**) {
   std::ostrstream oss;
   std::string s;
 
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/pcount.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstreambuf sb;
@@ -28,4 +28,6 @@
         assert(sb.pcount() == 2);
         sb.freeze(false);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.members/str.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::strstreambuf sb;
@@ -24,4 +24,6 @@
         assert(sb.str() == std::string("a"));
         sb.freeze(false);
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/overflow.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[12] = "abc";
@@ -43,4 +43,6 @@
         assert(sb.sputc('1') == '1');
         assert(sb.str() == std::string("12345678901"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/pbackfail.pass.cpp
@@ -27,7 +27,7 @@
     virtual int_type pbackfail(int_type c = EOF) {return base::pbackfail(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const char buf[] = "123";
@@ -58,4 +58,6 @@
         assert(sb.pbackfail(EOF) == EOF);
         assert(sb.str() == std::string("133"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekoff.pass.cpp
@@ -16,7 +16,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "0123456789";
@@ -53,4 +53,6 @@
         assert(sb.sputc('c') == 'c');
         assert(sb.str() == std::string("012a456c89"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/seekpos.pass.cpp
@@ -16,7 +16,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "0123456789";
@@ -35,4 +35,6 @@
         assert(sb.sputc('a') == 'a');
         assert(sb.str() == std::string("012a456789"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/setbuf.pass.cpp
@@ -15,7 +15,7 @@
 #include <strstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         char buf[] = "0123456789";
@@ -23,4 +23,6 @@
         assert(sb.pubsetbuf(0, 0) == &sb);
         assert(sb.str() == std::string("0123456789"));
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.virtuals/underflow.pass.cpp
@@ -27,7 +27,7 @@
     base::int_type underflow() {return base::underflow();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         char buf[10] = "123";
@@ -47,4 +47,6 @@
         assert(sb.underflow() == '4');
         assert(sb.underflow() == '4');
     }
+
+  return 0;
 }
Index: test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp
===================================================================
--- test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp
+++ test/std/depr/depr.str.strstreams/depr.strstreambuf/types.pass.cpp
@@ -14,7 +14,9 @@
 #include <strstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::streambuf, std::strstreambuf>::value), "");
+
+  return 0;
 }
Index: test/std/depr/exception.unexpected/nothing_to_do.pass.cpp
===================================================================
--- test/std/depr/exception.unexpected/nothing_to_do.pass.cpp
+++ test/std/depr/exception.unexpected/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
===================================================================
--- test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
+++ test/std/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp
@@ -22,7 +22,7 @@
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
 
     std::unexpected_handler old = std::get_unexpected();
@@ -37,4 +37,6 @@
     std::set_terminate(f3);
     (*old)();
     assert(0);
+
+  return 0;
 }
Index: test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp
===================================================================
--- test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp
+++ test/std/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp
@@ -22,7 +22,7 @@
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::unexpected_handler old = std::set_unexpected(f1);
     // verify there is a previous unexpected handler
@@ -33,4 +33,6 @@
     std::set_terminate(f3);
     (*old)();
     assert(0);
+
+  return 0;
 }
Index: test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp
===================================================================
--- test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp
+++ test/std/depr/exception.unexpected/unexpected.handler/unexpected_handler.pass.cpp
@@ -14,8 +14,10 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     std::unexpected_handler p = f;
     ((void)p);
+
+  return 0;
 }
Index: test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp
===================================================================
--- test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp
+++ test/std/depr/exception.unexpected/unexpected/unexpected.pass.cpp
@@ -19,9 +19,11 @@
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_unexpected(f1);
     std::unexpected();
     assert(false);
+
+  return 0;
 }
Index: test/std/depr/nothing_to_do.pass.cpp
===================================================================
--- test/std/depr/nothing_to_do.pass.cpp
+++ test/std/depr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/diagnostics/assertions/cassert.pass.cpp
===================================================================
--- test/std/diagnostics/assertions/cassert.pass.cpp
+++ test/std/diagnostics/assertions/cassert.pass.cpp
@@ -14,6 +14,8 @@
 #error assert not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp
+++ test/std/diagnostics/diagnostics.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/diagnostics/errno/cerrno.pass.cpp
===================================================================
--- test/std/diagnostics/errno/cerrno.pass.cpp
+++ test/std/diagnostics/errno/cerrno.pass.cpp
@@ -339,6 +339,8 @@
 #error errno not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/diagnostics/nothing_to_do.pass.cpp
===================================================================
--- test/std/diagnostics/nothing_to_do.pass.cpp
+++ test/std/diagnostics/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp
===================================================================
--- test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp
+++ test/std/diagnostics/std.exceptions/domain.error/domain_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::logic_error, std::domain_error>::value),
                  "std::is_base_of<std::logic_error, std::domain_error>::value");
@@ -38,4 +38,6 @@
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp
===================================================================
--- test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp
+++ test/std/diagnostics/std.exceptions/invalid.argument/invalid_argument.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::logic_error, std::invalid_argument>::value),
                  "std::is_base_of<std::logic_error, std::invalid_argument>::value");
@@ -38,4 +38,6 @@
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp
===================================================================
--- test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp
+++ test/std/diagnostics/std.exceptions/length.error/length_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::logic_error, std::length_error>::value),
                  "std::is_base_of<std::logic_error, std::length_error>::value");
@@ -38,4 +38,6 @@
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp
===================================================================
--- test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp
+++ test/std/diagnostics/std.exceptions/logic.error/logic_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::logic_error>::value),
                  "std::is_base_of<std::exception, std::logic_error>::value");
@@ -38,4 +38,6 @@
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp
===================================================================
--- test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp
+++ test/std/diagnostics/std.exceptions/out.of.range/out_of_range.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::logic_error, std::out_of_range>::value),
                  "std::is_base_of<std::logic_error, std::out_of_range>::value");
@@ -38,4 +38,6 @@
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp
===================================================================
--- test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp
+++ test/std/diagnostics/std.exceptions/overflow.error/overflow_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::runtime_error, std::overflow_error>::value),
                  "std::is_base_of<std::runtime_error, std::overflow_error>::value");
@@ -38,4 +38,6 @@
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp
===================================================================
--- test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp
+++ test/std/diagnostics/std.exceptions/range.error/range_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::runtime_error, std::range_error>::value),
                  "std::is_base_of<std::runtime_error, std::range_error>::value");
@@ -38,4 +38,6 @@
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp
===================================================================
--- test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp
+++ test/std/diagnostics/std.exceptions/runtime.error/runtime_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::runtime_error>::value),
                  "std::is_base_of<std::exception, std::runtime_error>::value");
@@ -38,4 +38,6 @@
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp
===================================================================
--- test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp
+++ test/std/diagnostics/std.exceptions/underflow.error/underflow_error.pass.cpp
@@ -14,7 +14,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::runtime_error, std::underflow_error>::value),
                  "std::is_base_of<std::runtime_error, std::underflow_error>::value");
@@ -38,4 +38,6 @@
     e2 = e;
     assert(e2.what() == msg);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/errc.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/errc.pass.cpp
+++ test/std/diagnostics/syserr/errc.pass.cpp
@@ -12,7 +12,7 @@
 
 #include <system_error>
 
-int main()
+int main(int, char**)
 {
     static_assert(static_cast<int>(std::errc::address_family_not_supported) == EAFNOSUPPORT, "");
     static_assert(static_cast<int>(std::errc::address_in_use) == EADDRINUSE, "");
@@ -100,4 +100,6 @@
     static_assert(static_cast<int>(std::errc::too_many_symbolic_link_levels) == ELOOP, "");
     static_assert(static_cast<int>(std::errc::value_too_large) == EOVERFLOW, "");
     static_assert(static_cast<int>(std::errc::wrong_protocol_type) == EPROTOTYPE, "");
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
+++ test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
@@ -39,7 +39,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test<false, void>();
     test<false, int>();
@@ -47,4 +47,6 @@
     test<false, std::string>();
 
     test<true, A>();
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
+++ test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
@@ -39,7 +39,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test<false, void>();
     test<false, int>();
@@ -47,4 +47,6 @@
     test<false, std::string>();
 
     test<true, A>();
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp
+++ test/std/diagnostics/syserr/syserr.hash/enabled_hash.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::error_code>();
     test_hash_enabled_for_type<std::error_condition>();
   }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
+++ test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
@@ -36,9 +36,11 @@
     ((void)result); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(2);
     test(10);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
+++ test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
@@ -36,9 +36,11 @@
     ((void)result); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test(0);
     test(2);
     test(10);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
+++ test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
@@ -20,7 +20,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::error_code e_code1(5, std::generic_category());
     std::error_code e_code2(5, std::system_category());
@@ -102,4 +102,6 @@
     assert(e_condition4 != e_condition2);
     assert(e_condition4 != e_condition3);
     assert(e_condition4 == e_condition4);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
@@ -18,7 +18,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     const std::error_category& e_cat2 = std::system_category();
@@ -30,4 +30,6 @@
     assert(!m3.empty());
     assert(m1 == m2);
     assert(m1 != m3);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp
@@ -27,8 +27,10 @@
     virtual std::string message(int) const {return std::string();}
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_nothrow_default_constructible<test1>::value,
                                  "error_category() must exist and be noexcept");
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/eq.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     const std::error_category& e_cat2 = std::generic_category();
     const std::error_category& e_cat3 = std::system_category();
     assert(e_cat1 == e_cat2);
     assert(!(e_cat1 == e_cat3));
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/lt.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     const std::error_category& e_cat2 = std::generic_category();
     const std::error_category& e_cat3 = std::system_category();
     assert(!(e_cat1 < e_cat2) && !(e_cat2 < e_cat1));
     assert((e_cat1 < e_cat3) || (e_cat3 < e_cat1));
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/neq.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     const std::error_category& e_cat2 = std::generic_category();
     const std::error_category& e_cat3 = std::system_category();
     assert(!(e_cat1 != e_cat2));
     assert(e_cat1 != e_cat3);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
@@ -35,7 +35,7 @@
     assert(errno == E2BIG);
 }
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::generic_category();
     std::string m1 = e_cat1.name();
@@ -43,4 +43,6 @@
     {
         test_message_for_bad_value();
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
@@ -35,7 +35,7 @@
     assert(errno == E2BIG);
 }
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::system_category();
     std::error_condition e_cond = e_cat1.default_error_condition(5);
@@ -47,4 +47,6 @@
     {
         test_message_for_bad_value();
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.overview/error_category.pass.cpp
@@ -12,8 +12,10 @@
 
 #include <system_error>
 
-int main()
+int main(int, char**)
 {
     std::error_category* p = 0;
     ((void)p);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
@@ -15,10 +15,12 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::generic_category();
     std::error_condition e_cond = e_cat.default_error_condition(static_cast<int>(std::errc::not_a_directory));
     assert(e_cond.category() == e_cat);
     assert(e_cond.value() == static_cast<int>(std::errc::not_a_directory));
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_error_code_int.pass.cpp
@@ -15,9 +15,11 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::generic_category();
     assert(e_cat.equivalent(std::error_code(5, e_cat), 5));
     assert(!e_cat.equivalent(std::error_code(5, e_cat), 6));
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/equivalent_int_error_condition.pass.cpp
@@ -15,10 +15,12 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::generic_category();
     std::error_condition e_cond = e_cat.default_error_condition(5);
     assert(e_cat.equivalent(5, e_cond));
     assert(!e_cat.equivalent(6, e_cond));
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.pass.cpp
@@ -33,11 +33,13 @@
     return std::error_code(static_cast<int>(x), std::generic_category());
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec(two);
         assert(ec.value() == 2);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/default.pass.cpp
@@ -15,9 +15,11 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::error_code ec;
     assert(ec.value() == 0);
     assert(ec.category() == std::system_category());
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/int_error_category.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec(6, std::system_category());
@@ -27,4 +27,6 @@
         assert(ec.value() == 8);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.pass.cpp
@@ -33,7 +33,7 @@
     return std::error_code(static_cast<int>(x), std::generic_category());
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec;
@@ -41,4 +41,6 @@
         assert(ec.value() == 2);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec;
@@ -29,4 +29,6 @@
         assert(ec.value() == 8);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/clear.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec;
@@ -26,4 +26,6 @@
         assert(ec.value() == 0);
         assert(ec.category() == std::system_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/lt.pass.cpp
@@ -16,11 +16,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_code ec1(6, std::generic_category());
         const std::error_code ec2(7, std::generic_category());
         assert(ec1 < ec2);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/make_error_code.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec = make_error_code(std::errc::operation_canceled);
         assert(ec.value() == static_cast<int>(std::errc::operation_canceled));
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.pass.cpp
@@ -18,9 +18,11 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream out;
     out << std::error_code(std::io_errc::stream);
     assert(out.str() == "iostream:1");
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.fail.cpp
@@ -22,7 +22,7 @@
     return ec;   // conversion to bool is explicit; should fail.
 }
 
-int main()
+int main(int, char**)
 {
     return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/bool.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_code ec(6, std::generic_category());
@@ -26,4 +26,6 @@
         const std::error_code ec(0, std::generic_category());
         assert(!static_cast<bool>(ec));
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/category.pass.cpp
@@ -15,8 +15,10 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_code ec(6, std::generic_category());
     assert(ec.category() == std::generic_category());
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/default_error_condition.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_code ec(6, std::generic_category());
@@ -27,4 +27,6 @@
         std::error_condition e_cond = ec.default_error_condition();
         assert(e_cond == ec);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/message.pass.cpp
@@ -16,8 +16,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_code ec(6, std::generic_category());
     assert(ec.message() == std::generic_category().message(6));
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.observers/value.pass.cpp
@@ -15,8 +15,10 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_code ec(6, std::system_category());
     assert(ec.value() == 6);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
@@ -14,10 +14,12 @@
 #include <system_error>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::error_code x;
     TEST_IGNORE_NODISCARD  x.category();   // returns a std::error_category &
     TEST_IGNORE_NODISCARD  x.default_error_condition(); // std::error_condition
     TEST_IGNORE_NODISCARD  x.message();    // returns a std::string
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/ErrorConditionEnum.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec(std::errc::not_a_directory);
         assert(ec.value() == static_cast<int>(std::errc::not_a_directory));
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/default.pass.cpp
@@ -15,9 +15,11 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::error_condition ec;
     assert(ec.value() == 0);
     assert(ec.category() == std::generic_category());
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.constructors/int_error_category.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec(6, std::system_category());
@@ -27,4 +27,6 @@
         assert(ec.value() == 8);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/ErrorConditionEnum.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec;
@@ -23,4 +23,6 @@
         assert(ec.value() == static_cast<int>(std::errc::not_enough_memory));
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec;
@@ -29,4 +29,6 @@
         assert(ec.value() == 8);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.modifiers/clear.pass.cpp
@@ -15,7 +15,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_condition ec;
@@ -26,4 +26,6 @@
         assert(ec.value() == 0);
         assert(ec.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/lt.pass.cpp
@@ -16,11 +16,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec1(6, std::generic_category());
         const std::error_condition ec2(7, std::generic_category());
         assert(ec1 < ec2);
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.nonmembers/make_error_condition.pass.cpp
@@ -15,11 +15,13 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec1 = std::make_error_condition(std::errc::message_size);
         assert(ec1.value() == static_cast<int>(std::errc::message_size));
         assert(ec1.category() == std::generic_category());
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/bool.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec(6, std::generic_category());
@@ -26,4 +26,6 @@
         const std::error_condition ec(0, std::generic_category());
         assert(!static_cast<bool>(ec));
     }
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/category.pass.cpp
@@ -15,8 +15,10 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_condition ec(6, std::generic_category());
     assert(ec.category() == std::generic_category());
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/message.pass.cpp
@@ -16,8 +16,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_condition ec(6, std::generic_category());
     assert(ec.message() == std::generic_category().message(6));
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.observers/value.pass.cpp
@@ -15,8 +15,10 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_condition ec(6, std::system_category());
     assert(ec.value() == 6);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
+++ test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
@@ -14,9 +14,11 @@
 #include <system_error>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::error_condition x = std::errc(0);
     TEST_IGNORE_NODISCARD  x.category();   // returns a std::error_condition &
     TEST_IGNORE_NODISCARD  x.message();    // returns a std::string
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp
+++ test/std/diagnostics/syserr/syserr.syserr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp
+++ test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code.pass.cpp
@@ -18,11 +18,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::system_error se(static_cast<int>(std::errc::not_a_directory),
                          std::generic_category(), "some text");
     assert(se.code() == std::make_error_code(std::errc::not_a_directory));
     std::string what_message(se.what());
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp
+++ test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_const_char_pointer.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string what_arg("test message");
     std::system_error se(make_error_code(std::errc::not_a_directory), what_arg.c_str());
@@ -26,4 +26,6 @@
     std::string what_message(se.what());
     assert(what_message.find(what_arg) != std::string::npos);
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp
+++ test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_error_code_string.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string what_arg("test message");
     std::system_error se(make_error_code(std::errc::not_a_directory), what_arg);
@@ -26,4 +26,6 @@
     std::string what_message(se.what());
     assert(what_message.find(what_arg) != std::string::npos);
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp
+++ test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category.pass.cpp
@@ -18,11 +18,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::system_error se(static_cast<int>(std::errc::not_a_directory),
                          std::generic_category());
     assert(se.code() == std::make_error_code(std::errc::not_a_directory));
     std::string what_message(se.what());
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp
+++ test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_const_char_pointer.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string what_arg("test message");
     std::system_error se(static_cast<int>(std::errc::not_a_directory),
@@ -27,4 +27,6 @@
     std::string what_message(se.what());
     assert(what_message.find(what_arg) != std::string::npos);
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp
+++ test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.members/ctor_int_error_category_string.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string what_arg("test message");
     std::system_error se(static_cast<int>(std::errc::not_a_directory),
@@ -27,4 +27,6 @@
     std::string what_message(se.what());
     assert(what_message.find(what_arg) != std::string::npos);
     assert(what_message.find("Not a directory") != std::string::npos);
+
+  return 0;
 }
Index: test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp
===================================================================
--- test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp
+++ test/std/diagnostics/syserr/syserr.syserr/syserr.syserr.overview/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/experimental/algorithms/alg.search/search.pass.cpp
===================================================================
--- test/std/experimental/algorithms/alg.search/search.pass.cpp
+++ test/std/experimental/algorithms/alg.search/search.pass.cpp
@@ -35,11 +35,13 @@
 };
 
 
-int main() {
+int main(int, char**) {
     typedef int * RI;
     static_assert((std::is_same<RI, decltype(std::experimental::search(RI(), RI(), MySearcher()))>::value), "" );
 
     RI it(nullptr);
     assert(it == std::experimental::search(it, it, MySearcher()));
     assert(searcher_called == 1);
+
+  return 0;
 }
Index: test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
===================================================================
--- test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
+++ test/std/experimental/filesystem/fs.req.macros/feature_macro.pass.cpp
@@ -25,4 +25,6 @@
 #endif
 #endif
 
-int main() { }
+int main(int, char**) { 
+  return 0;
+}
Index: test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
===================================================================
--- test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
+++ test/std/experimental/filesystem/fs.req.namespace/namespace.pass.cpp
@@ -15,9 +15,11 @@
 #include <experimental/filesystem>
 #include <type_traits>
 
-int main() {
+int main(int, char**) {
   static_assert(std::is_same<
           std::experimental::filesystem::path,
           std::experimental::filesystem::v1::path
       >::value, "");
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
@@ -121,7 +121,9 @@
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
@@ -117,7 +117,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
@@ -135,7 +135,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
@@ -126,7 +126,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
@@ -121,7 +121,9 @@
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
@@ -116,7 +116,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
@@ -129,7 +129,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
@@ -123,7 +123,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
@@ -82,7 +82,7 @@
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -92,4 +92,6 @@
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
@@ -89,7 +89,7 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -99,4 +99,6 @@
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
@@ -67,7 +67,7 @@
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -77,4 +77,6 @@
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
+++ test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
@@ -74,7 +74,7 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -84,4 +84,6 @@
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
Index: test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp
+++ test/std/experimental/func/func.searchers/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/experimental/func/header.functional.synop/includes.pass.cpp
===================================================================
--- test/std/experimental/func/header.functional.synop/includes.pass.cpp
+++ test/std/experimental/func/header.functional.synop/includes.pass.cpp
@@ -14,7 +14,9 @@
 
 #include <experimental/functional>
 
-int main()
+int main(int, char**)
 {
   std::function<int(int)> x;
+
+  return 0;
 }
Index: test/std/experimental/func/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/func/nothing_to_do.pass.cpp
+++ test/std/experimental/func/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/experimental/iterator/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/iterator/nothing_to_do.pass.cpp
+++ test/std/experimental/iterator/nothing_to_do.pass.cpp
@@ -8,4 +8,6 @@
 
 #include <experimental/iterator>
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
===================================================================
--- test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
+++ test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
@@ -24,7 +24,7 @@
 
 namespace exp = std::experimental;
 
-int main () {
+int main(int, char**) {
     const char eight = '8';
     const std::string nine = "9";
     const std::wstring ten = L"10";
@@ -54,4 +54,6 @@
     { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, ten); }
     { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, eleven); }
 
-    }
+    
+  return 0;
+}
Index: test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
===================================================================
--- test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
+++ test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.pass.cpp
@@ -39,7 +39,7 @@
     assert(sstream.str() == expected);
     }
 
-int main () {
+int main(int, char**) {
     const char chars[] = "0123456789";
     const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
 
@@ -49,4 +49,6 @@
     test('x', ints,  ints+10,  "10x11x12x13x14x15x16x17x18x19");
     test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
     test("z", ints,  ints+10,  "10z11z12z13z14z15z16z17z18z19");
-    }
+    
+  return 0;
+}
Index: test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
===================================================================
--- test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
+++ test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
@@ -67,7 +67,7 @@
     assert(sstream.str() == expected);
     }
 
-int main () {
+int main(int, char**) {
 {
     const char chars[] = "0123456789";
     const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
@@ -116,4 +116,6 @@
     test(mutating_delimiter(), chars, chars+10, L"0 1!2\"3#4$5%6&7'8(9");
     }
 
+
+  return 0;
 }
Index: test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
===================================================================
--- test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
+++ test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.pass.cpp
@@ -31,7 +31,7 @@
     assert( &ret == &oj );
     }
 
-int main () {
+int main(int, char**) {
 
     { exp::ostream_joiner<char>         oj(std::cout, '8');                 test(oj); }
     { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9"));    test(oj); }
@@ -42,4 +42,6 @@
     { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9"));    test(oj); }
     { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); test(oj); }
     { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11);                  test(oj); }
-    }
+    
+  return 0;
+}
Index: test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
===================================================================
--- test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
+++ test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.pass.cpp
@@ -31,7 +31,7 @@
     assert( &ret == &oj );
     }
 
-int main () {
+int main(int, char**) {
 
     { exp::ostream_joiner<char>         oj(std::cout, '8');                 test(oj); }
     { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9"));    test(oj); }
@@ -42,4 +42,6 @@
     { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9"));    test(oj); }
     { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); test(oj); }
     { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11);                  test(oj); }
-    }
+    
+  return 0;
+}
Index: test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
===================================================================
--- test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
+++ test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.pass.cpp
@@ -31,7 +31,7 @@
     assert( &ret == &oj );
     }
 
-int main () {
+int main(int, char**) {
 
     { exp::ostream_joiner<char>         oj(std::cout, '8');                 test(oj); }
     { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9"));    test(oj); }
@@ -42,4 +42,6 @@
     { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9"));    test(oj); }
     { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); test(oj); }
     { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11);                  test(oj); }
-    }
+    
+  return 0;
+}
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp
@@ -47,7 +47,7 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   std::pair<uintptr_t, uintptr_t> const TestCases[] = {
       {0, 0},
@@ -59,4 +59,6 @@
     do_test<coro::coroutine_handle<>>(TC.first, TC.second);
     do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
   }
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp
@@ -50,8 +50,10 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp
@@ -44,7 +44,7 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   std::pair<uintptr_t, uintptr_t> const TestCases[] = {
       {0, 0},
@@ -56,4 +56,6 @@
     do_test<coro::coroutine_handle<>>(TC.first, TC.second);
     do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
   }
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp
@@ -53,7 +53,7 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   std::pair<uintptr_t, uintptr_t> const TestCases[] = {
       {0, 0},
@@ -65,4 +65,6 @@
     do_test<coro::coroutine_handle<>>(TC.first, TC.second);
     do_test<coro::coroutine_handle<int>>(TC.first, TC.second);
   }
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp
@@ -36,8 +36,10 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test(coro::coroutine_handle<>{});
   do_test(coro::coroutine_handle<int>{});
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp
@@ -46,8 +46,10 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp
@@ -45,8 +45,10 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp
@@ -43,8 +43,10 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.fail.cpp
@@ -26,7 +26,7 @@
 
 namespace coro = std::experimental;
 
-int main()
+int main(int, char**)
 {
   {
     using H = coro::coroutine_handle<>;
@@ -42,4 +42,6 @@
     // expected-error@experimental/coroutine:* 1 {{coroutine_handle<promise_type>::from_address cannot be called with non-void pointers}}
     H::from_address((int*)nullptr); // expected-note {{requested here}}
   }
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp
@@ -38,8 +38,10 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test<coro::coroutine_handle<>>();
   do_test<coro::coroutine_handle<int>>();
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp
@@ -44,7 +44,7 @@
 // // 18.11.2.10 noop address
 // constexpr void* address() const noexcept;
 
-int main()
+int main(int, char**)
 {
   auto h = coro::noop_coroutine();
   coro::coroutine_handle<> base = h;
@@ -65,10 +65,12 @@
   assert(h.address() == base.address());
   assert(h.address() != nullptr);
   assert(coro::coroutine_handle<>::from_address(h.address()) == base);
+
+  return 0;
 }
 
 #else
 
-int main() {}
+int main(int, char**) { return 0; }
 
 #endif //  __has_builtin(__builtin_coro_noop)
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp
@@ -75,9 +75,11 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test(coro::coroutine_handle<int>{});
   do_test(coro::coroutine_handle<const int>{});
   do_runtime_test();
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp
@@ -53,8 +53,10 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test(coro::coroutine_handle<>{});
   do_test(coro::coroutine_handle<int>{});
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp
@@ -72,8 +72,10 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   do_test(coro::coroutine_handle<>{});
   do_test(coro::coroutine_handle<int>{});
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp
@@ -41,10 +41,12 @@
   static_assert(std::is_same<P, Expect>::value, "");
 };
 
-int main()
+int main(int, char**)
 {
   check_type<A*, A>();
   check_type<int*, A, int>();
   check_type<B*, B>();
   check_type<void, C>();
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp
@@ -60,7 +60,7 @@
   static_assert(!has_promise_type<Traits>(), "");
 }
 
-int main()
+int main(int, char**)
 {
   {
     check_type<A*, A>();
@@ -73,4 +73,6 @@
     check_no_type<E>();
     check_no_type<C, int>();
   }
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp
@@ -31,7 +31,7 @@
   return true;
 }
 
-int main()
+int main(int, char**)
 {
   using H = coro::coroutine_handle<>;
   using S = SuspendT;
@@ -69,4 +69,6 @@
     // suppress unused warnings for the global constexpr test variable
     ((void)constexpr_sa);
   }
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp
@@ -33,7 +33,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
   using H = coro::coroutine_handle<>;
   using S = SuspendT;
@@ -71,4 +71,6 @@
     // suppress unused warnings for the global constexpr test variable
     ((void)constexpr_sn);
   }
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp
@@ -59,10 +59,12 @@
 
 coro_t g() { B val = co_await B{}; }
 
-int main() {
+int main(int, char**) {
   last_value = -1;
   f(0);
   assert(last_value == 0);
   f(1);
   assert(last_value == 42);
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp
@@ -57,7 +57,7 @@
   g_resumed = true;
 }
 
-int main() {
+int main(int, char**) {
   assert(!f_started && !f_resumed && !g_started && !g_resumed);
   auto fret = f();
   assert(f_started && !f_resumed);
@@ -65,4 +65,6 @@
   assert(f_started && !f_resumed);
   g();
   assert(g_started && g_resumed);
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp
@@ -75,7 +75,7 @@
   co_return 200;
 }
 
-int main() {
+int main(int, char**) {
   auto c1 = f1();
   assert(f1_started && f1_resumed);
   assert(c1.value() == 100);
@@ -85,4 +85,6 @@
   assert(f2_started && !f2_resumed);
   assert(c2.value() == 0);
   assert(c2.error() == 42);
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
@@ -108,9 +108,11 @@
   assert(dtor_called == 1);
 }
 
-int main() {
+int main(int, char**) {
   a();
   b();
   c();
   d();
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp
@@ -95,8 +95,10 @@
   assert(sum == 10);
 }
 
-int main() {
+int main(int, char**) {
   test_count();
   test_range();
   test_mini_generator();
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp
@@ -164,7 +164,7 @@
 const int N = 100;
 channel* c = new channel[N + 1];
 
-int main() {
+int main(int, char**) {
   for (int i = 0; i < N; ++i)
     goroutine::go(pusher(c[i], c[i + 1]));
 
@@ -172,4 +172,6 @@
   int result = c[N].sync_pull();
 
   assert(result == 100);
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp
@@ -80,7 +80,9 @@
   return acc;
 }
 
-int main() {
+int main(int, char**) {
   int result = Do(1, 10, [](int a, int b) {return a + b;});
   assert(result == 46);
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp
@@ -72,11 +72,13 @@
 void Do1(func<int> f) { yield(f()); }
 void Do2(func<double> f) { yield(static_cast<int>(f())); }
 
-int main() {
+int main(int, char**) {
   Do1([] { return yield(43); });
   assert((yielded_values == std::vector<int>{43, 44}));
 
   yielded_values = {};
   Do2([] { return fyield(44); });
   assert((yielded_values == std::vector<int>{44, 46}));
+
+  return 0;
 }
Index: test/std/experimental/language.support/support.coroutines/includes.pass.cpp
===================================================================
--- test/std/experimental/language.support/support.coroutines/includes.pass.cpp
+++ test/std/experimental/language.support/support.coroutines/includes.pass.cpp
@@ -15,10 +15,11 @@
 
 #include <experimental/coroutine>
 
-int main(){
+int main(int, char**) {
   // std::nothrow is not implicitly defined by the compiler when the include is
   // missing, unlike other parts of <new>. Therefore we use std::nothrow to
   // test for #include <new>
   (void)std::nothrow;
 
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp
@@ -20,9 +20,11 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> T;
     static_assert(!std::is_copy_assignable<T>::value, "");
     static_assert(!std::is_move_assignable<T>::value, "");
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp
@@ -20,7 +20,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A1;
     {
@@ -44,4 +44,6 @@
         assert(a.resource() == a2.resource());
         assert(a2.resource() == (ex::memory_resource*)42);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp
@@ -23,7 +23,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     {
         static_assert(
@@ -45,4 +45,6 @@
         assert(a.resource() == &R1);
         assert(a2.resource() == ex::new_delete_resource());
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     {
         typedef ex::polymorphic_allocator<void> A;
@@ -41,4 +41,6 @@
         A const a(&R);
         assert(a.resource() == &R);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A1;
     typedef ex::polymorphic_allocator<char> A2;
@@ -53,4 +53,6 @@
         assert(a.resource() == a2.resource());
         assert(a2.resource() == (ex::memory_resource*)42);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp
@@ -26,7 +26,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A1;
     typedef ex::polymorphic_allocator<int> A2;
@@ -130,4 +130,6 @@
         assert(d1.checkIsEqualCalledEq(0));
         assert(d2.checkIsEqualCalledEq(1));
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp
@@ -26,7 +26,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A1;
     typedef ex::polymorphic_allocator<int> A2;
@@ -101,4 +101,6 @@
         assert(d1.checkIsEqualCalledEq(0));
         assert(d2.checkIsEqualCalledEq(1));
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp
@@ -80,7 +80,7 @@
 }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
-int main()
+int main(int, char**)
 {
     {
         ex::polymorphic_allocator<int> a;
@@ -108,4 +108,6 @@
         testAllocForSizeThrows<13>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp
@@ -34,7 +34,7 @@
     int x{0};
 };
 
-int main()
+int main(int, char**)
 {
     // pair<default_constructible, default_constructible> as T()
     {
@@ -49,4 +49,6 @@
         assert(ptr->second.x == 42);
         std::free(ptr);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
@@ -118,7 +118,7 @@
 template <class Tp>
 struct Print;
 
-int main()
+int main(int, char**)
 {
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -139,4 +139,6 @@
         test_pmr_not_uses_allocator<PMR>(p);
         test_pmr_uses_allocator<PMA>(p);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
@@ -114,7 +114,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -135,4 +135,6 @@
         test_pmr_not_uses_allocator<PMR>(std::move(p));
         test_pmr_uses_allocator<PMA>(std::move(p));
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
@@ -121,7 +121,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -140,4 +140,6 @@
         test_pmr_not_uses_allocator<PMR>(std::move(x), y);
         test_pmr_uses_allocator<PMA>(std::move(x), y);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
@@ -111,7 +111,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -159,4 +159,6 @@
         test_pmr_uses_allocator<PMA>(           t1, std::move(t2));
         test_pmr_uses_allocator<PMA>(std::move(t2),            t1);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
@@ -120,7 +120,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_evil<WidgetV0, WidgetV0>();
     test_evil<WidgetV0, WidgetV1>();
@@ -138,4 +138,6 @@
     test_evil<WidgetV3, WidgetV1>();
     test_evil<WidgetV3, WidgetV2>();
     test_evil<WidgetV3, WidgetV3>();
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
@@ -187,7 +187,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     using ET = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
@@ -223,4 +223,6 @@
         test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue, std::move(value));
         test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue, std::move(value));
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp
@@ -41,7 +41,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         ex::polymorphic_allocator<int> a;
@@ -58,4 +58,6 @@
         testForSizeAndAlign<73, MA>();
         testForSizeAndAlign<13, MA>();
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp
@@ -32,7 +32,7 @@
     ~destroyable() { --count; }
 };
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<double> A;
     {
@@ -48,4 +48,6 @@
         assert(count == 0);
         std::free(ptr);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A;
     {
@@ -53,4 +53,6 @@
         assert(a.resource() == mptr);
         assert(a.resource() == ex::get_default_resource());
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> A;
     {
@@ -49,4 +49,6 @@
         assert(other.resource() == mptr);
         assert(a.resource() == nullptr);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.overview/nothing_to_do.pass.cpp
@@ -6,4 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/nothing_to_do.pass.cpp
@@ -6,4 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
+++ test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp
@@ -21,7 +21,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef CountingAllocator<char> AllocT;
     typedef ex::resource_adaptor<AllocT> R;
@@ -49,4 +49,6 @@
         assert(P.move_constructed == 0);
         assert(r.get_allocator() == a);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
+++ test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp
@@ -21,7 +21,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef CountingAllocator<char> AllocT;
     typedef ex::resource_adaptor<AllocT> R;
@@ -40,4 +40,6 @@
         assert(P.move_constructed == 1);
         assert(r.get_allocator() == AllocT{P});
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
+++ test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp
@@ -23,7 +23,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     {
         typedef CountingAllocator<char> AllocT; // Not default constructible
@@ -36,4 +36,6 @@
         static_assert(std::is_default_constructible<R>::value, "");
         R r; ((void)r);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
+++ test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp
@@ -106,9 +106,11 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     check_allocate_deallocate<CountingAllocator<char>>();
     check_allocate_deallocate<MinAlignedAllocator<char>>();
     check_alloc_max_size();
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
+++ test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp
@@ -23,7 +23,7 @@
 using std::size_t;
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
 
     typedef CountingAllocator<char> Alloc1;
@@ -79,4 +79,6 @@
         assert(!m1.is_equal(m2));
         assert(!m2.is_equal(m1));
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
+++ test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp
@@ -19,7 +19,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     typedef ex::resource_adaptor<std::allocator<void>> R;
     typedef ex::resource_adaptor<std::allocator<long>> R2;
@@ -35,4 +35,6 @@
         static_assert(std::is_copy_assignable<R>::value, "");
         static_assert(std::is_move_assignable<R>::value, "");
    }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp
@@ -26,11 +26,13 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using StdDeque = std::deque<int, pmr::polymorphic_allocator<int>>;
     using PmrDeque = pmr::deque<int>;
     static_assert(std::is_same<StdDeque, PmrDeque>::value, "");
     PmrDeque d;
     assert(d.get_allocator().resource() == pmr::get_default_resource());
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp
@@ -26,11 +26,13 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using StdForwardList = std::forward_list<int, pmr::polymorphic_allocator<int>>;
     using PmrForwardList = pmr::forward_list<int>;
     static_assert(std::is_same<StdForwardList, PmrForwardList>::value, "");
     PmrForwardList d;
     assert(d.get_allocator().resource() == pmr::get_default_resource());
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp
@@ -26,11 +26,13 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using StdList = std::list<int, pmr::polymorphic_allocator<int>>;
     using PmrList = pmr::list<int>;
     static_assert(std::is_same<StdList, PmrList>::value, "");
     PmrList d;
     assert(d.get_allocator().resource() == pmr::get_default_resource());
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp
@@ -30,7 +30,7 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using K = int;
     using V = char;
@@ -65,4 +65,6 @@
         pmr::multimap<int, int> m;
         assert(m.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp
@@ -40,7 +40,7 @@
     static_assert(std::is_same<PmrMR, PmrTypedef>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     {
         test_match_result_typedef<const char*, pmr::cmatch>();
@@ -53,4 +53,6 @@
         pmr::smatch s;
         assert(s.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp
@@ -30,7 +30,7 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using V = char;
     using DC = std::less<V>;
@@ -63,4 +63,6 @@
         pmr::multiset<int> m;
         assert(m.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp
@@ -50,7 +50,7 @@
     static_assert(std::is_same<StdStr, PmrStr>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     {
         test_string_typedef<char,     pmr::string>();
@@ -69,4 +69,6 @@
         pmr::string s;
         assert(s.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp
@@ -36,7 +36,7 @@
 template <class T>
 struct MyPred : std::equal_to<T> {};
 
-int main()
+int main(int, char**)
 {
     using K = int;
     using V = char;
@@ -83,4 +83,6 @@
         pmr::unordered_multimap<int, int> m;
         assert(m.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp
@@ -36,7 +36,7 @@
 template <class T>
 struct MyPred : std::equal_to<T> {};
 
-int main()
+int main(int, char**)
 {
     using V = char;
     using DH = std::hash<V>;
@@ -81,4 +81,6 @@
         pmr::unordered_multiset<int> m;
         assert(m.get_allocator().resource() == pmr::get_default_resource());
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
+++ test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp
@@ -26,11 +26,13 @@
 
 namespace pmr = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     using StdVector = std::vector<int, pmr::polymorphic_allocator<int>>;
     using PmrVector = pmr::vector<int>;
     static_assert(std::is_same<StdVector, PmrVector>::value, "");
     PmrVector d;
     assert(d.get_allocator().resource() == pmr::get_default_resource());
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
+++ test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp
@@ -36,7 +36,7 @@
 
 using namespace std::experimental::pmr;
 
-int main() {
+int main(int, char**) {
     TestResource R;
     { // Test (A) and (B)
         memory_resource* p = get_default_resource();
@@ -70,4 +70,6 @@
         static_assert(noexcept(set_default_resource(nullptr)),
                       "set_default_resource() must be noexcept");
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
+++ test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp
@@ -92,10 +92,12 @@
 
 }
 
-int main()
+int main(int, char**)
 {
     static_assert(noexcept(ex::new_delete_resource()), "Must be noexcept");
     test_return();
     test_equality();
     test_allocate_deallocate();
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
+++ test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp
@@ -108,10 +108,12 @@
     assert(globalMemCounter.checkDeleteArrayCalledEq(0));
 }
 
-int main()
+int main(int, char**)
 {
     test_return();
     test_equality();
     test_allocate();
     test_deallocate();
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
+++ test/std/experimental/memory/memory.resource.synop/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource/construct.fail.cpp
===================================================================
--- test/std/experimental/memory/memory.resource/construct.fail.cpp
+++ test/std/experimental/memory/memory.resource/construct.fail.cpp
@@ -18,7 +18,9 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     ex::memory_resource m; // expected-error {{variable type 'ex::memory_resource' is an abstract class}}
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
+++ test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp
@@ -21,7 +21,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     // check return types
     {
@@ -72,4 +72,6 @@
         assert(r1.checkIsEqualCalledEq(1));
         assert(r2.checkIsEqualCalledEq(1));
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
+++ test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp
@@ -20,7 +20,7 @@
 
 namespace ex = std::experimental::pmr;
 
-int main()
+int main(int, char**)
 {
     // check return types
     {
@@ -71,4 +71,6 @@
         assert(!(mr2 != mr1));
         assert(r1.checkIsEqualCalledEq(0));
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
+++ test/std/experimental/memory/memory.resource/memory.resource.overview/nothing_to_do.pass.cpp
@@ -6,4 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
===================================================================
--- test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
+++ test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
@@ -18,9 +18,11 @@
 
 namespace ex = std::experimental::pmr;
 
-int main() {
+int main(int, char**) {
     ex::memory_resource *m = ex::new_delete_resource();
     m->do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
     m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
     m->do_is_equal(*m); // expected-error{{'do_is_equal' is a protected member}}
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
+++ test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp
@@ -31,7 +31,7 @@
 
 using std::experimental::pmr::memory_resource;
 
-int main()
+int main(int, char**)
 {
     TestResource R(42);
     auto& P = R.getController();
@@ -85,4 +85,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
+++ test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp
@@ -30,7 +30,7 @@
 
 using std::experimental::pmr::memory_resource;
 
-int main()
+int main(int, char**)
 {
     NullResource R(42);
     auto& P = R.getController();
@@ -70,4 +70,6 @@
         assert(P.dealloc_count == 2);
         assert(P.checkDealloc(p, s, a));
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
+++ test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp
@@ -26,7 +26,7 @@
 
 using std::experimental::pmr::memory_resource;
 
-int main()
+int main(int, char**)
 {
     static_assert(
         std::has_virtual_destructor<memory_resource>::value
@@ -55,4 +55,6 @@
         assert(TR::resource_constructed == 1);
         assert(TR::resource_destructed == 1);
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
+++ test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp
@@ -28,7 +28,7 @@
 
 using std::experimental::pmr::memory_resource;
 
-int main()
+int main(int, char**)
 {
     {
         memory_resource const* r1 = nullptr;
@@ -89,4 +89,6 @@
         assert(P2.checkIsEqualCalledEq(1));
         assert(P1.checkIsEqualCalledEq(1));
     }
+
+  return 0;
 }
Index: test/std/experimental/memory/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/memory/nothing_to_do.pass.cpp
+++ test/std/experimental/memory/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/experimental/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/nothing_to_do.pass.cpp
+++ test/std/experimental/nothing_to_do.pass.cpp
@@ -6,4 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
+++ test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
@@ -63,4 +63,6 @@
                            ex::__simd_abi<ex::_StorageKind::_Array, 16>>::value,
               "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/simd/simd.access/default.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.access/default.pass.cpp
+++ test/std/experimental/simd/simd.access/default.pass.cpp
@@ -210,7 +210,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_access<ex::native_simd<int>>();
   test_access<ex::fixed_size_simd<int, 4>>();
+
+  return 0;
 }
Index: test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
+++ test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
@@ -42,4 +42,6 @@
         ex::simd<int64_t, ex::simd_abi::scalar>>::value,
     "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp
+++ test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp
@@ -37,4 +37,6 @@
         ex::simd<float, ex::simd_abi::scalar>>::value,
     "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/simd/simd.cons/broadcast.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.cons/broadcast.pass.cpp
+++ test/std/experimental/simd/simd.cons/broadcast.pass.cpp
@@ -78,8 +78,10 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_broadcast<ex::native_simd<int>>();
   test_broadcast<ex::fixed_size_simd<int, 4>>();
   test_broadcast<ex::fixed_size_simd<int, 15>>();
+
+  return 0;
 }
Index: test/std/experimental/simd/simd.cons/default.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.cons/default.pass.cpp
+++ test/std/experimental/simd/simd.cons/default.pass.cpp
@@ -18,10 +18,12 @@
 
 namespace ex = std::experimental::parallelism_v2;
 
-int main() {
+int main(int, char**) {
   static_assert(ex::native_simd<int32_t>().size() > 0, "");
   static_assert(ex::fixed_size_simd<int32_t, 4>().size() == 4, "");
   static_assert(ex::fixed_size_simd<int32_t, 5>().size() == 5, "");
   static_assert(ex::fixed_size_simd<int32_t, 1>().size() == 1, "");
   static_assert(ex::fixed_size_simd<char, 32>().size() == 32, "");
+
+  return 0;
 }
Index: test/std/experimental/simd/simd.cons/generator.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.cons/generator.pass.cpp
+++ test/std/experimental/simd/simd.cons/generator.pass.cpp
@@ -82,9 +82,11 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
   assert(ex::native_simd<int32_t>::size() >= 4);
   test_generator<ex::native_simd<int32_t>>();
   test_generator<ex::fixed_size_simd<int32_t, 4>>();
+
+  return 0;
 }
Index: test/std/experimental/simd/simd.cons/load.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.cons/load.pass.cpp
+++ test/std/experimental/simd/simd.cons/load.pass.cpp
@@ -107,11 +107,13 @@
   assert(a[3] == 8);
 }
 
-int main() {
+int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
   assert(ex::native_simd<int32_t>::size() >= 4);
   test_load_ctor<ex::native_simd<int32_t>>();
   test_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
   test_converting_load_ctor<ex::native_simd<int32_t>>();
   test_converting_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
+
+  return 0;
 }
Index: test/std/experimental/simd/simd.mem/load.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.mem/load.pass.cpp
+++ test/std/experimental/simd/simd.mem/load.pass.cpp
@@ -111,11 +111,13 @@
   assert(a[3] == 8);
 }
 
-int main() {
+int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
   assert(ex::native_simd<int32_t>::size() >= 4);
   test_load<ex::native_simd<int32_t>>();
   test_load<ex::fixed_size_simd<int32_t, 4>>();
   test_converting_load<ex::native_simd<int32_t>>();
   test_converting_load<ex::fixed_size_simd<int32_t, 4>>();
+
+  return 0;
 }
Index: test/std/experimental/simd/simd.mem/store.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.mem/store.pass.cpp
+++ test/std/experimental/simd/simd.mem/store.pass.cpp
@@ -85,10 +85,12 @@
   assert(buffer[3] == 8.);
 }
 
-int main() {
+int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
   test_store<ex::native_simd<int32_t>>();
   test_store<ex::fixed_size_simd<int32_t, 4>>();
   test_converting_store<ex::native_simd<int32_t>>();
   test_converting_store<ex::fixed_size_simd<int32_t, 4>>();
+
+  return 0;
 }
Index: test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp
+++ test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp
@@ -28,4 +28,6 @@
                            ex::simd_abi::fixed_size<4>>::value,
               "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
+++ test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
@@ -109,4 +109,6 @@
 static_assert(!ex::is_abi_tag_v<ex::simd_mask<int>>, "");
 static_assert(!ex::is_abi_tag_v<ex::simd_mask<float>>, "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/simd/simd.traits/is_simd.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.traits/is_simd.pass.cpp
+++ test/std/experimental/simd/simd.traits/is_simd.pass.cpp
@@ -125,4 +125,6 @@
 static_assert(!ex::is_simd_v<ex::simd_mask<float>>, "");
 static_assert(!ex::is_simd_v<UserType>, "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
+++ test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
@@ -47,4 +47,6 @@
 static_assert(!ex::is_simd_flag_type_v<ex::simd<int8_t>>, "");
 static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<int8_t>>, "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
===================================================================
--- test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
+++ test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
@@ -148,4 +148,6 @@
 static_assert(!ex::is_simd_mask_v<ex::simd<float>>, "");
 static_assert(!ex::is_simd_mask_v<UserType>, "");
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp
===================================================================
--- test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp
+++ test/std/experimental/utilities/meta/meta.detect/detected_or.pass.cpp
@@ -33,7 +33,9 @@
     static_assert( std::is_same<Res, typename ex::detected_or_t<double, hasFoo, T>      >::value, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<yesFoo, int>();
     test<noFoo, double>();
+
+  return 0;
 }
Index: test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp
===================================================================
--- test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp
+++ test/std/experimental/utilities/meta/meta.detect/detected_t.pass.cpp
@@ -40,8 +40,10 @@
     static_assert( std::is_same<Res, typename ex::detected_t<callFoo, T>>::value, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<yesFoo, int>();
     test<noFoo, ex::nonesuch>();  // lookup failure returns nonesuch
     test<wrongFoo, std::string>();
+
+  return 0;
 }
Index: test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp
===================================================================
--- test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp
+++ test/std/experimental/utilities/meta/meta.detect/is_detected.pass.cpp
@@ -29,8 +29,10 @@
     static_assert( b == ex::is_detected_v<copy_assign_t, T>, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<int, true>();
     test<std::string, true>();
     test<not_assignable, false>();
+
+  return 0;
 }
Index: test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp
===================================================================
--- test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp
+++ test/std/experimental/utilities/meta/meta.detect/is_detected_convertible.pass.cpp
@@ -41,9 +41,11 @@
     static_assert( b == ex::is_detected_convertible_v<int, callFoo, T>, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<yesFoo, true>();
     test<noFoo, false>();
     test<wrongFoo, false>();
     test<convertibleFoo, true>();
+
+  return 0;
 }
Index: test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp
===================================================================
--- test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp
+++ test/std/experimental/utilities/meta/meta.detect/is_detected_exact.pass.cpp
@@ -40,9 +40,11 @@
     static_assert( b == ex::is_detected_exact_v<int, callFoo, T>, "" );
 }
 
-int main () {
+int main(int, char**) {
     test<yesFoo, true>();
     test<noFoo, false>();
     test<wrongFoo, false>();
     test<convertibleFoo, false>();
+
+  return 0;
 }
Index: test/std/experimental/utilities/nothing_to_do.pass.cpp
===================================================================
--- test/std/experimental/utilities/nothing_to_do.pass.cpp
+++ test/std/experimental/utilities/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp
@@ -20,4 +20,6 @@
 
 typedef propagate_const<X> P;
 
-int main() { static_assert(!std::is_assignable<P, const P &>::value, ""); }
+int main(int, char**) { static_assert(!std::is_assignable<P, const P &>::value, ""); 
+  return 0;
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<CopyConstructibleFromX> PY;
 
@@ -30,4 +30,6 @@
   p = x1;
 
   assert(*p==1);
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp
@@ -21,4 +21,6 @@
 typedef propagate_const<X> PX;
 typedef propagate_const<CopyConstructibleFromX> PY;
 
-int main() { static_assert(!std::is_assignable<PY, const PX &>::value, ""); }
+int main(int, char**) { static_assert(!std::is_assignable<PY, const PX &>::value, ""); 
+  return 0;
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -30,4 +30,6 @@
   p = x1;
 
   assert(*p==1);
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -28,4 +28,6 @@
   p2=std::move(p1);
 
   assert(*p2==1);
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> PX;
   typedef propagate_const<MoveConstructibleFromX> PY;
@@ -29,4 +29,6 @@
   py1=std::move(px2);
 
   assert(*py1==2);
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> PX;
   typedef propagate_const<MoveConstructibleFromX> PY;
@@ -29,4 +29,6 @@
   py1=std::move(px2);
 
   assert(*py1==2);
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp
@@ -20,8 +20,10 @@
 
 typedef propagate_const<ExplicitCopyConstructibleFromX> P;
 
-int main() {
+int main(int, char**) {
   static_assert(!std::is_convertible<P, X>::value, "");
   static_assert(std::is_constructible<P, X>::value, "");
+
+  return 0;
 }
 
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
@@ -25,7 +25,9 @@
   assert(*p==2);
 }
 
-int main() {
+int main(int, char**) {
   f(X(2));
+
+  return 0;
 }
 
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp
@@ -21,5 +21,7 @@
 typedef propagate_const<X> PX;
 typedef propagate_const<CopyConstructibleFromX> PY;
 
-int main() { static_assert(!std::is_constructible<PX, PY>::value, ""); }
+int main(int, char**) { static_assert(!std::is_constructible<PX, PY>::value, ""); 
+  return 0;
+}
 
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp
@@ -21,7 +21,9 @@
 typedef propagate_const<X> PX;
 typedef propagate_const<ExplicitMoveConstructibleFromX> PY;
 
-int main() {
+int main(int, char**) {
   static_assert(!std::is_convertible<PY, PX &&>::value, "");
   static_assert(std::is_constructible<PY, PX &&>::value, "");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
@@ -21,10 +21,12 @@
 typedef propagate_const<MoveConstructibleFromX> PY;
 typedef propagate_const<X> PX;
 
-int main() {
+int main(int, char**) {
   PX px(1);
   PY py(std::move(px));
 
   assert(*py==1);
+
+  return 0;
 }
 
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp
@@ -20,4 +20,6 @@
 
 typedef propagate_const<X> P;
 
-int main() { static_assert(!std::is_constructible<P, const P &>::value, ""); }
+int main(int, char**) { static_assert(!std::is_constructible<P, const P &>::value, ""); 
+  return 0;
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp
@@ -20,8 +20,10 @@
 
 typedef propagate_const<ExplicitX> P;
 
-int main() {
+int main(int, char**) {
   static_assert(!std::is_convertible<P, int>::value, "");
   static_assert(std::is_constructible<P, int>::value, "");
+
+  return 0;
 }
 
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
@@ -24,4 +24,6 @@
 {
 }
 
-int main() { f(2); }
+int main(int, char**) { f(2); 
+  return 0;
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
@@ -18,11 +18,13 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
   P p1(2);
   P p2(std::move(p1));
   assert(*p2 == 2);
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
@@ -27,7 +27,9 @@
   return p;
 }
 
-int main() {
+int main(int, char**) {
   constexpr P p = f();
   static_assert(*p==2,"");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp
@@ -20,4 +20,6 @@
 
 typedef propagate_const<X> P;
 
-int main() { static_assert(!std::is_convertible<P, int *>::value, ""); }
+int main(int, char**) { static_assert(!std::is_convertible<P, int *>::value, ""); 
+  return 0;
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
@@ -27,7 +27,9 @@
   return p;
 }
 
-int main() {
+int main(int, char**) {
   constexpr P p = f();
   static_assert(*(p.get())==2,"");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
@@ -27,7 +27,9 @@
   return p;
 }
 
-int main() {
+int main(int, char**) {
   constexpr P p = f();
   static_assert(*(p.operator->())==2,"");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
@@ -18,7 +18,7 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<XWithImplicitIntStarConversion> P;
 
@@ -31,4 +31,6 @@
   *ptr_1 = 2;
 
   assert(*ptr_1==2);
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
@@ -18,11 +18,13 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
   constexpr P p(1);
 
   static_assert(*p==1,"");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp
@@ -20,6 +20,8 @@
 
 typedef propagate_const<X> P;
 
-int main() {
+int main(int, char**) {
   static_assert(!std::is_convertible<const P, const int *>::value, "");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
@@ -18,11 +18,13 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
   constexpr P p(1);
 
   static_assert(*(p.get())==1, "");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
@@ -18,11 +18,13 @@
 
 using std::experimental::propagate_const;
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
   constexpr P p(1);
 
   static_assert(*(p.operator->())==1,"");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
@@ -24,4 +24,6 @@
 
 constexpr const int *ptr_1 = p;
 
-int main() { assert(*ptr_1 == 1); }
+int main(int, char**) { assert(*ptr_1 == 1); 
+  return 0;
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
@@ -21,11 +21,13 @@
 bool swap_called = false;
 void swap(X &, X &) { swap_called = true; }
 
-int main() {
+int main(int, char**) {
   typedef propagate_const<X> P;
   P p1(1);
   P p2(2);
   p1.swap(p2);
   assert(swap_called);
+
+  return 0;
 }
 
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
@@ -31,7 +31,7 @@
 };
 } // namespace std
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -40,4 +40,6 @@
   auto h = std::hash<P>();
 
   assert(h(p)==99);
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
@@ -20,7 +20,7 @@
 
 constexpr bool operator==(const X &x1, const X &x2) { return x1.i_ == x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -32,4 +32,6 @@
 
   assert(c(p1_1,p2_1));
   assert(!c(p1_1,p3_2));
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
@@ -20,7 +20,7 @@
 
 constexpr bool operator>(const X &x1, const X &x2) { return x1.i_ > x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -34,4 +34,6 @@
   assert(!c(p2_1,p1_1));
   assert(!c(p1_1,p3_2));
   assert(c(p3_2,p1_1));
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
@@ -20,7 +20,7 @@
 
 constexpr bool operator>=(const X &x1, const X &x2) { return x1.i_ >= x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -34,4 +34,6 @@
   assert(c(p2_1,p1_1));
   assert(!c(p1_1,p3_2));
   assert(c(p3_2,p1_1));
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
@@ -20,7 +20,7 @@
 
 constexpr bool operator<(const X &x1, const X &x2) { return x1.i_ < x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -34,4 +34,6 @@
   assert(!c(p2_1,p1_1));
   assert(c(p1_1,p3_2));
   assert(!c(p3_2,p1_1));
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
@@ -20,7 +20,7 @@
 
 constexpr bool operator<=(const X &x1, const X &x2) { return x1.i_ <= x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -34,4 +34,6 @@
   assert(c(p2_1,p1_1));
   assert(c(p1_1,p3_2));
   assert(!c(p3_2,p1_1));
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
@@ -20,7 +20,7 @@
 
 constexpr bool operator!=(const X &x1, const X &x2) { return x1.i_ != x2.i_; }
 
-int main() {
+int main(int, char**) {
 
   typedef propagate_const<X> P;
 
@@ -32,4 +32,6 @@
 
   assert(!c(p1_1,p2_1));
   assert(c(p1_1,p3_2));
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
@@ -33,7 +33,7 @@
   return false;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -60,4 +60,6 @@
 
   static_assert(!(p1_1==nullptr),"");
   static_assert(!(nullptr==p1_1),"");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
@@ -24,7 +24,7 @@
   return lhs.i_ >= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -50,4 +50,6 @@
   static_assert(x1_1 >= p2_1, "");
   static_assert(!(x1_1 >= p3_2), "");
   static_assert(x3_2 >= p1_1, "");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
@@ -24,7 +24,7 @@
   return lhs.i_ > rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -46,4 +46,6 @@
 
   static_assert(!(x1_1 > p2_1), "");
   static_assert(x3_2 > p1_1, "");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
@@ -24,7 +24,7 @@
   return lhs.i_ <= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -51,4 +51,6 @@
   static_assert(x1_1 <= p3_2, "");
   static_assert(!(x3_2 <= p1_1), "");
 
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
@@ -24,7 +24,7 @@
   return lhs.i_ < rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -46,4 +46,6 @@
 
   static_assert(!(p1_1 < x1_1), "");
   static_assert(p1_1 < x3_2, "");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
@@ -33,7 +33,7 @@
   return true;
 }
 
-int main() {
+int main(int, char**) {
   constexpr X x1_1(1);
   constexpr X x2_1(1);
   constexpr X x3_2(2);
@@ -58,4 +58,6 @@
 
   static_assert(p1_1!=nullptr,"");
   static_assert(nullptr!=p1_1,"");
+
+  return 0;
 }
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
===================================================================
--- test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
@@ -21,10 +21,12 @@
 bool swap_called = false;
 void swap(X &, X &) { swap_called = true; }
 
-int main() {
+int main(int, char**) {
   typedef propagate_const<X> P;
   P p1(1);
   P p2(2);
   swap(p1, p2);
   assert(swap_called);
+
+  return 0;
 }
Index: test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
===================================================================
--- test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
+++ test/std/experimental/utilities/utility/utility.erased.type/erased_type.pass.cpp
@@ -10,8 +10,10 @@
 
 #include <experimental/utility>
 
-int main()
+int main(int, char**)
 {
   std::experimental::erased_type e;
   ((void)e);
+
+  return 0;
 }
Index: test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
===================================================================
--- test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
+++ test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
@@ -14,6 +14,8 @@
 #   error "<experimental/utility> must include <utility>"
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
===================================================================
--- test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
+++ test/std/input.output/file.streams/c.files/cinttypes.pass.cpp
@@ -877,7 +877,7 @@
     ((void)t); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test<std::int8_t >();
     test<std::int16_t>();
@@ -927,4 +927,6 @@
     static_assert((std::is_same<decltype(std::strtoumax("", (char**)0, 0)), std::uintmax_t>::value), "");
     static_assert((std::is_same<decltype(std::wcstoimax(L"", (wchar_t**)0, 0)), std::intmax_t>::value), "");
     static_assert((std::is_same<decltype(std::wcstoumax(L"", (wchar_t**)0, 0)), std::uintmax_t>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/file.streams/c.files/cstdio.pass.cpp
===================================================================
--- test/std/input.output/file.streams/c.files/cstdio.pass.cpp
+++ test/std/input.output/file.streams/c.files/cstdio.pass.cpp
@@ -85,7 +85,7 @@
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
-int main()
+int main(int, char**)
 {
     std::FILE* fp = 0;
     std::fpos_t fpos = std::fpos_t();
@@ -154,4 +154,6 @@
     static_assert((std::is_same<decltype(std::puts("")), int>::value), "");
     static_assert((std::is_same<decltype(std::vprintf(" ",va)), int>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/input.output/file.streams/c.files/gets.fail.cpp
===================================================================
--- test/std/input.output/file.streams/c.files/gets.fail.cpp
+++ test/std/input.output/file.streams/c.files/gets.fail.cpp
@@ -13,7 +13,9 @@
 
 #include <cstdio>
 
-int main()
+int main(int, char**)
 {
     (void) std::gets((char *) NULL);
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.assign/member_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -50,4 +50,6 @@
         assert(f2.sgetc() == L'2');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -52,4 +52,6 @@
         assert(f2.sgetc() == L'2');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.assign/nonmember_swap.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -52,4 +52,6 @@
         assert(f2.sgetc() == L'2');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::filebuf f;
@@ -26,4 +26,6 @@
         std::wfilebuf f;
         assert(!f.is_open());
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -50,4 +50,6 @@
         assert(f2.sgetc() == L'2');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp
@@ -19,7 +19,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
 
   fs::path p = get_temp_file_name();
   {
@@ -52,4 +52,6 @@
     assert(f.sbumpc() == L'3');
   }
   remove(p.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.members/open_pointer.pass.cpp
@@ -14,7 +14,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -47,4 +47,6 @@
         assert(f.sbumpc() == L'3');
     }
     remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.virtuals/overflow.pass.cpp
@@ -36,7 +36,7 @@
     virtual int_type overflow(int_type c = traits_type::eof()) {return base::overflow(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test_buf<char> f;
@@ -140,4 +140,6 @@
         assert(f.sbumpc() == -1);
     }
     std::remove("overflow.dat");
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.virtuals/pbackfail.pass.cpp
@@ -32,7 +32,7 @@
     virtual int_type pbackfail(int_type c = traits_type::eof()) {return base::pbackfail(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test_buf<char> f;
@@ -60,4 +60,6 @@
             assert(f.sgetc() == '2');
         }
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         char buf[10];
@@ -62,4 +62,6 @@
         assert(f.sgetc() == L'l');
     }
     std::remove("seekoff.dat");
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
@@ -36,7 +36,7 @@
     virtual int_type underflow() {return base::underflow();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test_buf<char> f;
@@ -121,4 +121,6 @@
         assert(f.sbumpc() == 0x4E53);
         assert(f.sbumpc() == static_cast<Traits::int_type>(-1));
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp
+++ test/std/input.output/file.streams/fstreams/filebuf/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_streambuf<char>, std::basic_filebuf<char> >::value), "");
     static_assert((std::is_same<std::basic_filebuf<char>::char_type, char>::value), "");
@@ -30,4 +30,6 @@
     static_assert((std::is_same<std::basic_filebuf<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_filebuf<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_filebuf<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.assign/member_swap.pass.cpp
@@ -35,7 +35,7 @@
   return names;
 }
 
-int main()
+int main(int, char**)
 {
     std::pair<std::string, std::string> temp_files = get_temp_file_names();
     std::string& temp1 = temp_files.first;
@@ -87,4 +87,6 @@
     }
     std::remove(temp1.c_str());
     std::remove(temp2.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -46,4 +46,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.assign/nonmember_swap.pass.cpp
@@ -37,7 +37,7 @@
   return names;
 }
 
-int main()
+int main(int, char**)
 {
     std::pair<std::string, std::string> temp_files = get_temp_file_names();
     std::string& temp1 = temp_files.first;
@@ -89,4 +89,6 @@
     }
     std::remove(temp1.c_str());
     std::remove(temp2.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         std::fstream fs;
@@ -24,4 +24,6 @@
     {
         std::wfstream fs;
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -44,4 +44,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp
@@ -23,7 +23,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
   fs::path p = get_temp_file_name();
   {
     std::fstream fs(p, std::ios_base::in | std::ios_base::out |
@@ -45,4 +45,6 @@
     assert(x == 3.25);
   }
   std::remove(p.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.cons/pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -40,4 +40,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -42,4 +42,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.members/close.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -38,4 +38,6 @@
         assert(!fs.is_open());
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main() {
+int main(int, char**) {
   std::filesystem::path p = get_temp_file_name();
   {
     std::fstream stream;
@@ -48,4 +48,6 @@
     assert(x == 3.25);
   }
   std::remove(p.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.members/open_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -46,4 +46,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.members/open_string.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -46,4 +46,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream.members/rdbuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::fstream fs;
@@ -26,4 +26,6 @@
         std::wfstream fs;
         assert(fs.rdbuf());
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp
+++ test/std/input.output/file.streams/fstreams/fstream/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_iostream<char>, std::basic_fstream<char> >::value), "");
     static_assert((std::is_same<std::basic_fstream<char>::char_type, char>::value), "");
@@ -30,4 +30,6 @@
     static_assert((std::is_same<std::basic_fstream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_fstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_fstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs1("test.dat");
@@ -38,4 +38,6 @@
         fs2 >> x;
         assert(x == 3.25);
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fso("test.dat");
@@ -36,4 +36,6 @@
         fs >> x;
         assert(x == 3.25);
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.assign/nonmember_swap.pass.cpp
@@ -17,7 +17,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs1("test.dat");
@@ -39,4 +39,6 @@
         fs2 >> x;
         assert(x == 3.25);
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs;
@@ -24,4 +24,6 @@
     {
         std::wifstream fs;
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fso("test.dat");
@@ -34,4 +34,6 @@
         fs >> x;
         assert(x == 3.25);
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
   {
     fs::path p;
     static_assert(!std::is_convertible<fs::path, std::ifstream>::value,
@@ -49,4 +49,6 @@
   // std::wifstream(const fs::path&, std::ios_base::openmode) is tested in
   // test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
   // which creates writable files.
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.cons/pointer.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs("test.dat");
@@ -36,4 +36,6 @@
     // std::wifstream(const char*, std::ios_base::openmode) is tested in
     // test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
     // which creates writable files.
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.cons/string.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs(std::string("test.dat"));
@@ -36,4 +36,6 @@
     // std::wifstream(const std::string&, std::ios_base::openmode) is tested in
     // test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
     // which creates writable files.
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.members/close.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs;
@@ -34,4 +34,6 @@
         fs.close();
         assert(!fs.is_open());
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp
@@ -19,7 +19,7 @@
 #include <filesystem>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   {
     std::ifstream fs;
     assert(!fs.is_open());
@@ -44,4 +44,6 @@
     fs >> c;
     assert(c == L'r');
   }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.members/open_pointer.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs;
@@ -42,4 +42,6 @@
         fs >> c;
         assert(c == L'r');
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.members/open_string.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs;
@@ -42,4 +42,6 @@
         fs >> c;
         assert(c == L'r');
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream.members/rdbuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream fs("test.dat");
@@ -28,4 +28,6 @@
         std::wfilebuf* fb = fs.rdbuf();
         assert(fb->sgetc() == L'r');
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ifstream/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_istream<char>, std::basic_ifstream<char> >::value), "");
     static_assert((std::is_same<std::basic_ifstream<char>::char_type, char>::value), "");
@@ -30,4 +30,6 @@
     static_assert((std::is_same<std::basic_ifstream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_ifstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ifstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.assign/member_swap.pass.cpp
@@ -35,7 +35,7 @@
   return names;
 }
 
-int main()
+int main(int, char**)
 {
     std::pair<std::string, std::string> temp_files = get_temp_file_names();
     std::string& temp1 = temp_files.first;
@@ -95,4 +95,6 @@
         assert(x == 3.25);
     }
     std::remove(temp2.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -48,4 +48,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.assign/nonmember_swap.pass.cpp
@@ -36,7 +36,7 @@
   return names;
 }
 
-int main()
+int main(int, char**)
 {
     std::pair<std::string, std::string> temp_files = get_temp_file_names();
     std::string& temp1 = temp_files.first;
@@ -96,4 +96,6 @@
         assert(x == 3.25);
     }
     std::remove(temp2.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         std::ofstream fs;
@@ -24,4 +24,6 @@
     {
         std::wofstream fs;
     }
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -46,4 +46,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
   fs::path p = get_temp_file_name();
   {
     static_assert(!std::is_convertible<fs::path, std::ofstream>::value,
@@ -65,4 +65,6 @@
     assert(x == 3.25);
   }
   std::remove(p.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.cons/pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -54,4 +54,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -54,4 +54,6 @@
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.members/close.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -38,4 +38,6 @@
         assert(!fs.is_open());
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp
@@ -22,7 +22,7 @@
 
 namespace fs = std::filesystem;
 
-int main() {
+int main(int, char**) {
   fs::path p = get_temp_file_name();
   {
     std::ofstream fs;
@@ -58,4 +58,6 @@
     assert(c == L'a');
   }
   std::remove(p.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.members/open_pointer.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -54,4 +54,6 @@
         assert(c == L'a');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.members/open_string.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -54,4 +54,6 @@
         assert(c == L'a');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream.members/rdbuf.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
@@ -32,4 +32,6 @@
         assert(fb->sputc(L'r') == L'r');
     }
     std::remove(temp.c_str());
+
+  return 0;
 }
Index: test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp
===================================================================
--- test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp
+++ test/std/input.output/file.streams/fstreams/ofstream/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <fstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_ostream<char>, std::basic_ofstream<char> >::value), "");
     static_assert((std::is_same<std::basic_ofstream<char>::char_type, char>::value), "");
@@ -30,4 +30,6 @@
     static_assert((std::is_same<std::basic_ofstream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_ofstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ofstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/file.streams/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/file.streams/nothing_to_do.pass.cpp
+++ test/std/input.output/file.streams/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp
+++ test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default.pass.cpp
@@ -18,7 +18,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   // Default
   {
@@ -27,4 +27,6 @@
     directory_entry e;
     assert(e.path() == path());
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp
+++ test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/default_const.pass.cpp
@@ -19,7 +19,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   // Default
   {
@@ -28,4 +28,6 @@
     const directory_entry e;
     assert(e.path() == path());
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
+++ test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/comparisons.pass.cpp
@@ -74,7 +74,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_comparison_signatures();
   test_comparisons_simple();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp
+++ test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/path.pass.cpp
@@ -81,7 +81,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_path_method();
   test_path_conversion();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
+++ test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
     {
         static_assert(std::is_nothrow_default_constructible<fs::directory_iterator>::value, "");
     }
@@ -31,4 +31,6 @@
         const fs::directory_iterator d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
+++ test/std/input.output/filesystems/class.directory_iterator/types.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
     using namespace fs;
     using D = directory_iterator;
     ASSERT_SAME_TYPE(D::value_type, directory_entry);
@@ -33,4 +33,6 @@
     ASSERT_SAME_TYPE(D::pointer, const directory_entry*);
     ASSERT_SAME_TYPE(D::reference, const directory_entry&);
     ASSERT_SAME_TYPE(D::iterator_category, std::input_iterator_tag);
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp
+++ test/std/input.output/filesystems/class.file_status/file_status.cons.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_convertible.hpp"
 
 
-int main() {
+int main(int, char**) {
  using namespace fs;
   // Default ctor
   {
@@ -56,4 +56,6 @@
     assert(f.type()  == file_type::regular);
     assert(f.permissions() == perms::owner_read);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp
+++ test/std/input.output/filesystems/class.file_status/file_status.mods.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
 
   file_status st;
@@ -45,4 +45,6 @@
     st.permissions(perms::owner_read);
     assert(st.permissions() == perms::owner_read);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp
+++ test/std/input.output/filesystems/class.file_status/file_status.obs.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
 
   const file_status st(file_type::regular, perms::owner_read);
@@ -41,4 +41,6 @@
                  "operation must return perms");
     assert(st.permissions() == perms::owner_read);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp
+++ test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.pass.cpp
@@ -94,8 +94,10 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   static_assert(std::is_base_of<std::system_error, fs::filesystem_error>::value, "");
   test_constructors();
   test_signatures();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp
@@ -97,8 +97,10 @@
 
 }
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   checkIteratorConcepts();
   checkBeginEndBasic(); // See path.decompose.pass.cpp for more tests.
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
@@ -311,7 +311,7 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : Cases) {
@@ -335,4 +335,6 @@
     doAppendSourceAllocTest<wchar_t>(TC);
   }
   test_sfinae();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.assign/braced_init.pass.cpp
@@ -22,9 +22,11 @@
 #include "count_new.hpp"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   path p("abc");
   p = {};
   assert(p.native() == "");
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.assign/copy.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_copy_assignable<path>::value, "");
   static_assert(!std::is_nothrow_copy_assignable<path>::value, "should not be noexcept");
@@ -32,4 +32,6 @@
   assert(p.native() == s);
   assert(p2.native() == s);
   assert(&pref == &p2);
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.assign/move.pass.cpp
@@ -22,7 +22,7 @@
 #include "count_new.hpp"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_nothrow_move_assignable<path>::value, "");
   assert(globalMemCounter.checkOutstandingNewEq(0));
@@ -38,4 +38,6 @@
     assert(p.native() != s); // Testing moved from state
     assert(&pref == &p2);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
@@ -228,7 +228,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   for (auto const& MS : PathList) {
     RunTestCase<char>(MS);
     RunTestCase<wchar_t>(MS);
@@ -237,4 +237,6 @@
     RunStringMoveTest(MS);
   }
   test_sfinae();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
@@ -184,7 +184,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_compare_basic();
   test_compare_elements();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
@@ -325,7 +325,7 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : Cases) {
@@ -384,4 +384,6 @@
     doConcatECharTest<char32_t>(TC);
   }
   test_sfinae();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.construct/copy.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_copy_constructible<path>::value, "");
   static_assert(!std::is_nothrow_copy_constructible<path>::value, "should not be noexcept");
@@ -30,4 +30,6 @@
   path p2(p);
   assert(p.native() == s);
   assert(p2.native() == s);
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.construct/default.pass.cpp
@@ -21,9 +21,11 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_nothrow_default_constructible<path>::value, "");
   const path p;
   assert(p.empty());
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.construct/move.pass.cpp
@@ -22,7 +22,7 @@
 #include "count_new.hpp"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   static_assert(std::is_nothrow_move_constructible<path>::value, "");
   assert(globalMemCounter.checkOutstandingNewEq(0));
@@ -36,4 +36,6 @@
     assert(p2.native() == s);
     assert(p.native() != s); // Testing moved from state
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
@@ -117,7 +117,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   for (auto const& MS : PathList) {
     RunTestCase<char>(MS);
     RunTestCase<wchar_t>(MS);
@@ -125,4 +125,6 @@
     RunTestCase<char32_t>(MS);
   }
   test_sfinae();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     fs::path c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
@@ -208,8 +208,10 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
   decompPathTest();
   decompFilenameTest();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp
@@ -26,7 +26,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main() {
+int main(int, char**) {
   // clang-format off
   struct {
     std::string input;
Index: test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp
@@ -27,7 +27,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main() {
+int main(int, char**) {
   // clang-format off
   struct {
     std::string input;
Index: test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.pass.cpp
@@ -33,7 +33,7 @@
 // generic_string<C, T, A> forwards to string<C, T, A>. Tests for
 // string<C, T, A>() are in "path.native.op/string_alloc.pass.cpp".
 // generic_string is minimally tested here.
-int main()
+int main(int, char**)
 {
   using namespace fs;
   using CharT = wchar_t;
@@ -51,4 +51,6 @@
     assert(Alloc::alloc_count > 0);
     assert(Alloc::outstanding_alloc() == 1);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp
@@ -31,7 +31,7 @@
 
 MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   auto const& MS = longString;
@@ -57,4 +57,6 @@
     std::u32string s = p.generic_u32string();
     assert(s == (const char32_t*)MS);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.pass.cpp
@@ -24,7 +24,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   {
     path p;
@@ -40,4 +40,6 @@
     p2.clear();
     assert(p2.empty());
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.pass.cpp
@@ -39,7 +39,7 @@
     , {"\\foo\\/bar\\/baz\\"}
   };
 
-int main()
+int main(int, char**)
 {
   // This operation is an identity operation on linux.
   using namespace fs;
@@ -50,4 +50,6 @@
     assert(p.native() == TC.value);
     assert(&Ref == &p);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
@@ -57,7 +57,7 @@
     , {"bar/../baz/./file.txt", "bar/../baz/./"}
   };
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : TestCases) {
@@ -69,4 +69,6 @@
     assert(&Ref == &p);
     assert(!p.has_filename());
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.pass.cpp
@@ -51,7 +51,7 @@
     , {"foo..cpp", "foo.", ""}
 };
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : TestCases) {
@@ -68,4 +68,6 @@
     assert(p == TC.expect);
     assert(&Ref == &p);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
@@ -47,7 +47,7 @@
     , {"/foo\\baz/bong", "/foo\\baz/bar", "bar"}
   };
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   for (auto const & TC : TestCases) {
@@ -67,4 +67,6 @@
       ASSERT_EQ(p, p2);
     }
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.pass.cpp
@@ -41,7 +41,7 @@
 #undef LONG_STR1
 #undef LONG_STR2
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   {
@@ -76,4 +76,6 @@
     }
     assert(p1 == Val);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.pass.cpp
@@ -23,7 +23,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   const char* const value = "hello world";
@@ -38,4 +38,6 @@
     assert(p.c_str() == str_value);
     assert(p.native().c_str() == p.c_str());
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp
@@ -32,7 +32,7 @@
 
 MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   auto const& MS = longString;
@@ -58,4 +58,6 @@
     std::u32string s = p.u32string();
     assert(s == (const char32_t*)MS);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.pass.cpp
@@ -22,7 +22,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   const char* const value = "hello world";
@@ -35,4 +35,6 @@
     path p(value);
     assert(p.native() == value);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.pass.cpp
@@ -23,7 +23,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   using string_type = path::string_type;
@@ -42,4 +42,6 @@
     assert(s == value);
     assert(p == value);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp
@@ -116,7 +116,7 @@
   /////////////////////////////////////////////////////////////////////////////
 }
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   {
@@ -133,4 +133,6 @@
     doLongStringTest<char16_t>(S);
     doLongStringTest<char32_t>(S);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.member/path.query/tested_in_path_decompose.pass.cpp
@@ -28,4 +28,6 @@
 // bool is_relative() const;
 
 // tested in path.decompose
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
+++ test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.cpp
@@ -20,7 +20,9 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   ConvToPath LHS, RHS;
   (void)(LHS / RHS); // expected-error {{invalid operands to binary expression}}
+
+  return 0;
 }
\ No newline at end of file
Index: test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.nonmember/append_op.pass.cpp
@@ -20,7 +20,7 @@
 #include "filesystem_test_helper.hpp"
 
 // This is mainly tested via the member append functions.
-int main()
+int main(int, char**)
 {
   using namespace fs;
   path p1("abc");
@@ -30,4 +30,6 @@
 
   path p4 = p1 / "def";
   assert(p4 == "abc/def");
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
+++ test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.cpp
@@ -21,7 +21,7 @@
   }
 };
 
-int main() {
+int main(int, char**) {
   ConvToPath LHS, RHS;
   (void)(LHS == RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS != RHS); // expected-error {{invalid operands to binary expression}}
@@ -29,4 +29,6 @@
   (void)(LHS <= RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS > RHS); // expected-error {{invalid operands to binary expression}}
   (void)(LHS >= RHS); // expected-error {{invalid operands to binary expression}}
+
+  return 0;
 }
\ No newline at end of file
Index: test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops_tested_elsewhere.pass.cpp
@@ -10,4 +10,6 @@
 
 // The comparison operators are tested as part of [path.compare]
 // in class.path/path.members/path.compare.pass.cpp
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.nonmember/hash_value_tested_elswhere.pass.cpp
@@ -10,4 +10,6 @@
 
 // The "hash_value" function is tested as part of [path.compare]
 // in class.path/path.members/path.compare.pass.cpp
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp
@@ -25,7 +25,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main()
+int main(int, char**)
 {
   using namespace fs;
   const char* In1 = "abcd/efg";
@@ -48,4 +48,6 @@
     path p = fs::u8path(In3, In3End);
     assert(p == In1);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.nonmember/path.io.pass.cpp
@@ -88,10 +88,12 @@
   static_assert(!is_istreamable<decltype(std::wcin), std::string>::value, "");
 }
 
-int main() {
+int main(int, char**) {
   doIOTest<char>();
   doIOTest<wchar_t>();
   //doIOTest<char16_t>();
   //doIOTest<char32_t>();
   test_LWG2989();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.pass.cpp
@@ -62,7 +62,9 @@
 }
 
 
-int main() {
+int main(int, char**) {
   doIOTest<char16_t>();
   doIOTest<char32_t>();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp
+++ test/std/input.output/filesystems/class.path/path.nonmember/swap.pass.cpp
@@ -22,7 +22,7 @@
 
 
 // NOTE: this is tested in path.members/path.modifiers via the member swap.
-int main()
+int main(int, char**)
 {
   using namespace fs;
   const char* value1 = "foo/bar/baz";
@@ -45,4 +45,6 @@
     assert(p1.native() == value1);
     assert(p2.native() == value2);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/class.path/synop.pass.cpp
===================================================================
--- test/std/input.output/filesystems/class.path/synop.pass.cpp
+++ test/std/input.output/filesystems/class.path/synop.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 
 
-int main() {
+int main(int, char**) {
   using namespace fs;
   ASSERT_SAME_TYPE(path::value_type, char);
   ASSERT_SAME_TYPE(path::string_type, std::basic_string<path::value_type>);
@@ -34,4 +34,6 @@
     const char* dummy = &path::preferred_separator;
     ((void)dummy);
   }
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp
+++ test/std/input.output/filesystems/fs.enum/enum.copy_options.pass.cpp
@@ -22,7 +22,7 @@
 
 constexpr fs::copy_options ME(int val) { return static_cast<fs::copy_options>(val); }
 
-int main() {
+int main(int, char**) {
   typedef fs::copy_options E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -59,4 +59,6 @@
           E::create_symlinks     == ME(128) &&
           E::create_hard_links   == ME(256),
         "Expected enumeration values do not match");
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp
+++ test/std/input.output/filesystems/fs.enum/enum.directory_options.pass.cpp
@@ -23,7 +23,7 @@
 
 constexpr fs::directory_options ME(int val) { return static_cast<fs::directory_options>(val); }
 
-int main() {
+int main(int, char**) {
   typedef fs::directory_options E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -41,4 +41,6 @@
         E::skip_permission_denied   == ME(2),
         "Expected enumeration values do not match");
 
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp
+++ test/std/input.output/filesystems/fs.enum/enum.file_type.pass.cpp
@@ -21,7 +21,7 @@
 
 constexpr fs::file_type ME(int val) { return static_cast<fs::file_type>(val); }
 
-int main() {
+int main(int, char**) {
   typedef fs::file_type E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -43,4 +43,6 @@
           E::socket == ME(7) &&
           E::unknown == ME(8),
         "Expected enumeration values do not match");
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp
+++ test/std/input.output/filesystems/fs.enum/enum.path.format.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   typedef fs::path::format E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -34,4 +34,6 @@
           E::auto_format   != E::generic_format &&
           E::native_format != E::generic_format,
         "Expected enumeration values are not unique");
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp
+++ test/std/input.output/filesystems/fs.enum/enum.perm_options.pass.cpp
@@ -25,7 +25,7 @@
   return static_cast<fs::perm_options>(val);
 }
 
-int main() {
+int main(int, char**) {
   typedef fs::perm_options E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -44,4 +44,6 @@
         E::remove   == ME(4) &&
         E::nofollow == ME(8),
         "Expected enumeration values do not match");
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp
+++ test/std/input.output/filesystems/fs.enum/enum.perms.pass.cpp
@@ -23,7 +23,7 @@
 
 constexpr fs::perms ME(int val) { return static_cast<fs::perms>(val); }
 
-int main() {
+int main(int, char**) {
   typedef fs::perms E;
   static_assert(std::is_enum<E>::value, "");
 
@@ -60,4 +60,6 @@
         E::mask         == ME(07777) &&
         E::unknown      == ME(0xFFFF),
         "Expected enumeration values do not match");
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp
+++ test/std/input.output/filesystems/fs.error.report/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp
+++ test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.pass.cpp
@@ -39,7 +39,9 @@
   ASSERT_SAME_TYPE(Period, std::nano);
 }
 
-int main() {
+int main(int, char**) {
   test_trivial_clock();
   test_time_point_resolution_and_range();
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp
+++ test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.pass.cpp
@@ -25,7 +25,7 @@
 #include "filesystem_test_helper.hpp"
 
 
-int main() {
+int main(int, char**) {
   // clang-format off
   struct {
     std::string input;
Index: test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp
+++ test/std/input.output/filesystems/fs.req.macros/feature_macro.pass.cpp
@@ -25,4 +25,6 @@
 #endif
 #endif
 
-int main() { }
+int main(int, char**) { 
+  return 0;
+}
Index: test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
===================================================================
--- test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
+++ test/std/input.output/filesystems/fs.req.namespace/namespace.fail.cpp
@@ -23,6 +23,8 @@
 // expected-error@-5 {{expected namespace name}}
 #endif
 
-int main() {
+int main(int, char**) {
 
+
+  return 0;
 }
Index: test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp
===================================================================
--- test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp
+++ test/std/input.output/filesystems/fs.req.namespace/namespace.pass.cpp
@@ -17,9 +17,11 @@
 
 using namespace std::filesystem;
 
-int main() {
+int main(int, char**) {
   static_assert(std::is_same<
           path,
           std::filesystem::path
       >::value, "");
+
+  return 0;
 }
Index: test/std/input.output/input.output.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/input.output.general/nothing_to_do.pass.cpp
+++ test/std/input.output/input.output.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp
+++ test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  -$1,234,567.89");
@@ -72,4 +72,6 @@
         is >> std::get_money(x, true);
         assert(x == -123456789);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
+++ test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  Sat Dec 31 23:55:59 2061");
@@ -72,4 +72,6 @@
         assert(is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
+++ test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
@@ -50,7 +50,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -88,4 +88,6 @@
         os << std::put_money(x, true);
         assert(sb.str() == L"-USD 1,234,567.89");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
+++ test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
@@ -50,7 +50,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -83,4 +83,6 @@
         os << std::put_time(&t, L"%a %b %d %H:%M:%S %Y");
         assert(sb.str() == L"Sat Dec 31 23:55:59 2061");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/member_swap.pass.cpp
@@ -33,7 +33,7 @@
     void swap(test_iostream& s) {base::swap(s);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -81,4 +81,6 @@
         assert(is2.precision() == 6);
         assert(is2.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.pass.cpp
@@ -38,7 +38,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -86,4 +86,6 @@
         assert(is2.precision() == 6);
         assert(is2.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.pass.cpp
@@ -38,7 +38,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -72,4 +72,6 @@
         assert(is.precision() == 6);
         assert(is.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/streambuf.pass.cpp
@@ -23,7 +23,7 @@
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -51,4 +51,6 @@
         assert(is.getloc().name() == "C");
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.dest/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/iostreamclass/types.pass.cpp
@@ -24,7 +24,7 @@
 #include <istream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_istream<char>, std::basic_iostream<char> >::value), "");
     static_assert((std::is_base_of<std::basic_ostream<char>, std::basic_iostream<char> >::value), "");
@@ -33,4 +33,6 @@
     static_assert((std::is_same<std::basic_iostream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_iostream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_iostream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/bool.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/double.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/float.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp
@@ -41,7 +41,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -76,4 +76,6 @@
         assert(!is.eof());
         assert( is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_double.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/long_long.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/pointer.pass.cpp
@@ -44,7 +44,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -97,4 +97,6 @@
         assert( is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp
@@ -41,7 +41,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -76,4 +76,6 @@
         assert(!is.eof());
         assert( is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_int.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_long_long.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/unsigned_short.pass.cpp
@@ -40,7 +40,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(!is.eof());
         assert(!is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.reqmts/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/basic_ios.pass.cpp
@@ -27,11 +27,13 @@
     return is;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
         is >> f;
         assert(f_called == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/chart.pass.cpp
@@ -38,7 +38,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -83,4 +83,6 @@
         assert(!is.fail());
         assert(c == L'c');
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/ios_base.pass.cpp
@@ -25,11 +25,13 @@
     return is;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
         is >> f;
         assert(f_called == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/istream.pass.cpp
@@ -27,11 +27,13 @@
     return is;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((std::streambuf*)0);
         is >> f;
         assert(f_called == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char.pass.cpp
@@ -38,7 +38,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -66,4 +66,6 @@
         assert(!is.fail());
         assert(c == 'c');
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/signed_char_pointer.pass.cpp
@@ -38,7 +38,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   abcdefghijk    ");
@@ -103,4 +103,6 @@
         assert(std::string((char*)s) == "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
@@ -55,7 +55,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("testing...");
@@ -65,4 +65,6 @@
         assert(sb2.str() == "testing...");
         assert(is.gcount() == 10);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char.pass.cpp
@@ -38,7 +38,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -66,4 +66,6 @@
         assert(!is.fail());
         assert(c == 'c');
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/unsigned_char_pointer.pass.cpp
@@ -38,7 +38,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   abcdefghijk    ");
@@ -103,4 +103,6 @@
         assert(std::string((char*)s) == "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/wchar_t_pointer.pass.cpp
@@ -38,7 +38,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   abcdefghijk    ");
@@ -114,4 +114,6 @@
         assert(std::string(s) == "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.formatted/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.manip/ws.pass.cpp
@@ -39,7 +39,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   123");
@@ -75,4 +75,6 @@
         assert(is.eof());
         assert(is.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp
@@ -47,7 +47,7 @@
 bool called = false;
 void operator>>(std::istream&, A&&){ called = true; }
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("   123");
@@ -68,4 +68,6 @@
         assert(&out == &ss);
         assert(called);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/get.pass.cpp
@@ -37,7 +37,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -96,4 +96,6 @@
         assert(c == L'c');
         assert(is.gcount() == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/get_chart.pass.cpp
@@ -37,7 +37,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("          ");
@@ -99,4 +99,6 @@
         assert(c == L'c');
         assert(is.gcount() == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size.pass.cpp
@@ -48,7 +48,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  \n    \n ");
@@ -158,4 +158,6 @@
         assert(is.gcount() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/get_pointer_size_chart.pass.cpp
@@ -48,7 +48,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  *    * ");
@@ -158,4 +158,6 @@
         assert(is.gcount() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
@@ -52,7 +52,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("testing\n...");
@@ -84,4 +84,6 @@
         assert(!is.fail());
         assert(is.gcount() == 3);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
@@ -53,7 +53,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("testing*...");
@@ -85,4 +85,6 @@
         assert(!is.fail());
         assert(is.gcount() == 3);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
@@ -48,7 +48,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  \n    \n ");
@@ -142,4 +142,6 @@
         assert(is.gcount() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
@@ -48,7 +48,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("  *    * ");
@@ -142,4 +142,6 @@
         assert(is.gcount() == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore.pass.cpp
@@ -38,7 +38,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 1\n2345\n6");
@@ -72,4 +72,6 @@
         assert(!is.fail());
         assert(is.gcount() == 6);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int bad=-1;
     std::ostringstream os;
@@ -30,4 +30,6 @@
     is.ignore(ignoreLen);
     std::istringstream::pos_type b=is.tellg();
     assert((b-a)==ignoreLen);
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/peek.pass.cpp
@@ -37,7 +37,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 1\n2345\n6");
@@ -65,4 +65,6 @@
         assert(!is.fail());
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/putback.pass.cpp
@@ -37,7 +37,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -85,4 +85,6 @@
         assert(is.bad());
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/read.pass.cpp
@@ -37,7 +37,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -77,4 +77,6 @@
         assert( is.fail());
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/readsome.pass.cpp
@@ -37,7 +37,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 1234567890");
@@ -81,4 +81,6 @@
         assert(std::wstring(s, 1) == L"0");
         assert(is.readsome(s, 5) == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg.pass.cpp
@@ -44,7 +44,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -71,4 +71,6 @@
         assert(is.good());
         assert(!is.eof());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/seekg_off.pass.cpp
@@ -52,7 +52,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -83,4 +83,6 @@
         assert(is.good());
         assert(!is.eof());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/sync.pass.cpp
@@ -46,7 +46,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -60,4 +60,6 @@
         assert(is.sync() == 0);
         assert(sync_called == 2);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/tellg.pass.cpp
@@ -47,7 +47,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -59,4 +59,6 @@
         std::wistream is(&sb);
         assert(is.tellg() == 5);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream.unformatted/unget.pass.cpp
@@ -37,7 +37,7 @@
     CharT* egptr() const {return base::egptr();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb(" 123456789");
@@ -77,4 +77,6 @@
         assert(is.bad());
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream/istream.assign/member_swap.pass.cpp
@@ -33,7 +33,7 @@
     void swap(test_istream& s) {base::swap(s);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -81,4 +81,6 @@
         assert(is2.precision() == 6);
         assert(is2.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.pass.cpp
@@ -38,7 +38,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -86,4 +86,6 @@
         assert(is2.precision() == 6);
         assert(is2.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp
+++ test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.cpp
@@ -48,7 +48,9 @@
 };
 
 
-int main()
+int main(int, char**)
 {
 
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.pass.cpp
@@ -36,7 +36,7 @@
         : base(std::move(s)) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -70,4 +70,6 @@
         assert(is.precision() == 6);
         assert(is.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream/istream.cons/streambuf.pass.cpp
@@ -23,7 +23,7 @@
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -51,4 +51,6 @@
         assert(is.getloc().name() == "C");
         assert(is.gcount() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream/istream_sentry/ctor.pass.cpp
@@ -49,7 +49,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::istream is((testbuf<char>*)0);
@@ -124,4 +124,6 @@
         assert(sync_called == 0);
         assert(sb.gptr() == sb.eback());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp
+++ test/std/input.output/iostream.format/input.streams/istream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <istream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_ios<char>, std::basic_istream<char> >::value), "");
     static_assert((std::is_same<std::basic_istream<char>::char_type, char>::value), "");
@@ -31,4 +31,6 @@
     static_assert((std::is_same<std::basic_istream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_istream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_istream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/nothing_to_do.pass.cpp
+++ test/std/input.output/iostream.format/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.assign/member_swap.pass.cpp
@@ -33,7 +33,7 @@
     void swap(test_ostream& s) {base::swap(s);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -81,4 +81,6 @@
         assert(os2.precision() == 6);
         assert(os2.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.pass.cpp
@@ -38,7 +38,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb1;
@@ -86,4 +86,6 @@
         assert(os2.precision() == 6);
         assert(os2.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.cons/move.pass.cpp
@@ -38,7 +38,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -68,4 +68,6 @@
         assert(os.precision() == 6);
         assert(os.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.cons/streambuf.pass.cpp
@@ -23,7 +23,7 @@
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -49,4 +49,6 @@
         assert(os.precision() == 6);
         assert(os.getloc().name() == "C");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.formatted.reqmts/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -87,4 +87,6 @@
         os << b;
         assert(sb.str() == "false");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "-10.5");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "-10.5");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "fffffff6");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "fffffff6");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "-10.5");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "fffffffffffffff6");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
@@ -45,7 +45,7 @@
     assert(ss.str() == expected);
 }
 
-int main()
+int main(int, char**)
 {
     const std::ios_base::fmtflags o = std::ios_base::oct;
     const std::ios_base::fmtflags d = std::ios_base::dec;
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
@@ -58,7 +58,7 @@
     assert(str == expected);
 }
 
-int main()
+int main(int, char**)
 {
 
     test_octal<uint16_t>(                "177777");
@@ -110,4 +110,6 @@
         test_hex<unsigned long long>("FFFFFFFFFFFFFFFF");
         test_hex<         long long>("FFFFFFFFFFFFFFFF");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -87,4 +87,6 @@
         os << n;
         assert(os.good());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "fff6");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "fff6");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "fffffff6");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "fffffffffffffff6");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -79,4 +79,6 @@
         os << n;
         assert(sb.str() == "fff6");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == L"a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == L"123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == "a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == "123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == L"a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == L"123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == "a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == "123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == "a    ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -84,4 +84,6 @@
         assert(sb.str() == "123  ");
         assert(os.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
@@ -57,7 +57,7 @@
     return os;
 }
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -66,4 +66,6 @@
         os << f;
         assert( (os.flags() & std::ios_base::uppercase));
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -57,4 +57,6 @@
         os << std::uppercase;
         assert( (os.flags() & std::ios_base::uppercase));
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
@@ -57,7 +57,7 @@
     return os;
 }
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -65,4 +65,6 @@
         os << f;
         assert(sb.str() == "testing...");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
@@ -55,7 +55,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -65,4 +65,6 @@
         os << &sb2;
         assert(sb.str() == "testing...");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
@@ -58,7 +58,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -76,4 +76,6 @@
         assert(sync_called == 2);
         assert(os.good());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
@@ -49,7 +49,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -67,4 +67,6 @@
         assert(sb.str().back() == 0);
         assert(os.good());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.manip/flush.pass.cpp
@@ -38,7 +38,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -54,4 +54,6 @@
         assert(sync_called == 2);
         assert(os.good());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
@@ -54,7 +54,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -66,4 +66,6 @@
         std::wostream(&sb) << L"123";
         assert(sb.str() == L"123");
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp.pass.cpp
@@ -36,7 +36,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         seekpos_called = 0;
@@ -64,4 +64,6 @@
         assert(seekpos_called == 1);
         assert(os.rdstate() == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.seeks/seekp2.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         seekoff_called = 0;
@@ -66,4 +66,6 @@
         assert(seekoff_called == 1);
         assert(os.rdstate() == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.seeks/tellp.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -50,4 +50,6 @@
         assert(os.tellp() == 10);
         assert(seekoff_called == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.unformatted/flush.pass.cpp
@@ -38,7 +38,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -50,4 +50,6 @@
         assert(os.bad());
         assert(sync_called == 2);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -72,4 +72,6 @@
         assert(sb.str() == "a");
         assert(os.good());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
@@ -48,7 +48,7 @@
         }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::wostream os((std::wstreambuf*)0);
@@ -72,4 +72,6 @@
         assert(sb.str() == s);
         assert(os.good());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <ostream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_ios<char>, std::basic_ostream<char> >::value), "");
     static_assert((std::is_same<std::basic_ostream<char>::char_type, char>::value), "");
@@ -31,4 +31,6 @@
     static_assert((std::is_same<std::basic_ostream<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_ostream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ostream<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream_sentry/construct.pass.cpp
@@ -33,7 +33,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -57,4 +57,6 @@
         assert(bool(s));
         assert(sync_called == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp
+++ test/std/input.output/iostream.format/output.streams/ostream_sentry/destruct.pass.cpp
@@ -35,7 +35,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ostream os((std::streambuf*)0);
@@ -75,4 +75,6 @@
         assert(sync_called == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
+++ test/std/input.output/iostream.format/quoted.manip/quoted.pass.cpp
@@ -123,7 +123,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     both_ways ( "" );   // This is a compilation check
 
@@ -173,8 +173,12 @@
     assert ( unquote (  "" ) ==  "" ); // nothing there
     assert ( unquote ( L"" ) == L"" ); // nothing there
     test_padding ();
-    }
+    
+    return 0;
+}
 
 #else
-int main() {}
+int main(int, char**) {
+  return 0;
+}
 #endif
Index: test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
===================================================================
--- test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
+++ test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
@@ -30,7 +30,7 @@
 
 
 
-int main()
+int main(int, char**)
 {
     round_trip ( "Hi Mom" );
 }
Index: test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
===================================================================
--- test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
+++ test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
@@ -36,7 +36,7 @@
 
 
 
-int main()
+int main(int, char**)
 {
     round_trip ( "Hi Mom" );
 }
Index: test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp
+++ test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp
@@ -22,7 +22,7 @@
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -52,4 +52,6 @@
         os << std::resetiosflags(std::ios_base::skipws);
         assert(!(os.flags() & std::ios_base::skipws));
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/std.manip/setbase.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/std.manip/setbase.pass.cpp
+++ test/std/input.output/iostream.format/std.manip/setbase.pass.cpp
@@ -22,7 +22,7 @@
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -72,4 +72,6 @@
         os << std::setbase(15);
         assert((os.flags() & std::ios_base::basefield) == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/std.manip/setfill.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/std.manip/setfill.pass.cpp
+++ test/std/input.output/iostream.format/std.manip/setfill.pass.cpp
@@ -21,7 +21,7 @@
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -35,4 +35,6 @@
         os << std::setfill(L'*');
         assert(os.fill() == L'*');
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp
+++ test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp
@@ -22,7 +22,7 @@
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -52,4 +52,6 @@
         os << std::setiosflags(std::ios_base::oct);
         assert(os.flags() & std::ios_base::oct);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp
+++ test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp
@@ -22,7 +22,7 @@
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -48,4 +48,6 @@
         os << std::setprecision(10);
         assert(os.precision() == 10);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.format/std.manip/setw.pass.cpp
===================================================================
--- test/std/input.output/iostream.format/std.manip/setw.pass.cpp
+++ test/std/input.output/iostream.format/std.manip/setw.pass.cpp
@@ -22,7 +22,7 @@
     testbuf() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb;
@@ -48,4 +48,6 @@
         os << std::setw(10);
         assert(os.width() == 10);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostream.forward/iosfwd.pass.cpp
===================================================================
--- test/std/input.output/iostream.forward/iosfwd.pass.cpp
+++ test/std/input.output/iostream.forward/iosfwd.pass.cpp
@@ -17,7 +17,7 @@
     ((void)p); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test<std::char_traits<char>*          >();
     test<std::char_traits<wchar_t>*       >();
@@ -119,4 +119,6 @@
     test<std::fpos<std::mbstate_t>*>();
     test<std::streampos*           >();
     test<std::wstreampos*          >();
+
+  return 0;
 }
Index: test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp
===================================================================
--- test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp
+++ test/std/input.output/iostream.objects/narrow.stream.objects/cerr.pass.cpp
@@ -13,7 +13,7 @@
 #include <iostream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::cerr << "Hello World!\n";
@@ -25,4 +25,6 @@
 #endif
     assert(std::cerr.flags() & std::ios_base::unitbuf);
 #endif  // 0
+
+  return 0;
 }
Index: test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp
===================================================================
--- test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp
+++ test/std/input.output/iostream.objects/narrow.stream.objects/cin.pass.cpp
@@ -15,7 +15,7 @@
 #include <iostream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::cout << "Hello World!\n";
@@ -30,4 +30,6 @@
     assert(std::cin.tie() == &std::cout);
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp
===================================================================
--- test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp
+++ test/std/input.output/iostream.objects/narrow.stream.objects/clog.pass.cpp
@@ -12,11 +12,13 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::clog << "Hello World!\n";
 #else
     (void)std::clog;
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp
===================================================================
--- test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp
+++ test/std/input.output/iostream.objects/narrow.stream.objects/cout.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::cout << "Hello World!\n";
@@ -25,4 +25,6 @@
 #else  // 0
     (void)std::cout;
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp
===================================================================
--- test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp
+++ test/std/input.output/iostream.objects/wide.stream.objects/wcerr.pass.cpp
@@ -13,7 +13,7 @@
 #include <iostream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::wcerr << L"Hello World!\n";
@@ -25,4 +25,6 @@
 #endif
     assert(std::wcerr.flags() & std::ios_base::unitbuf);
 #endif  // 0
+
+  return 0;
 }
Index: test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp
===================================================================
--- test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp
+++ test/std/input.output/iostream.objects/wide.stream.objects/wcin.pass.cpp
@@ -15,7 +15,7 @@
 #include <iostream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::wcout << L"Hello World!\n";
@@ -30,4 +30,6 @@
     assert(std::wcin.tie() == &std::wcout);
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp
===================================================================
--- test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp
+++ test/std/input.output/iostream.objects/wide.stream.objects/wclog.pass.cpp
@@ -12,11 +12,13 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::wclog << L"Hello World!\n";
 #else
     (void)std::wclog;
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp
===================================================================
--- test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp
+++ test/std/input.output/iostream.objects/wide.stream.objects/wcout.pass.cpp
@@ -14,11 +14,13 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
 #if 0
     std::wcout << L"Hello World!\n";
 #else
     (void)std::wcout;
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp
+++ test/std/input.output/iostreams.base/fpos/fpos.members/state.pass.cpp
@@ -15,9 +15,11 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::fpos<int> f;
     f.state(3);
     assert(f.state() == 3);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp
+++ test/std/input.output/iostreams.base/fpos/fpos.operations/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(5);
@@ -24,4 +24,6 @@
     assert(q == P(11));
     p += o;
     assert(p == q);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp
+++ test/std/input.output/iostreams.base/fpos/fpos.operations/ctor_int.pass.cpp
@@ -15,9 +15,11 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(5);
     assert(p == P(5));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp
+++ test/std/input.output/iostreams.base/fpos/fpos.operations/difference.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(11);
     P q(6);
     std::streamoff o = p - q;
     assert(o == 5);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp
+++ test/std/input.output/iostreams.base/fpos/fpos.operations/eq_int.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(5);
     P q(6);
     assert(p == p);
     assert(p != q);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp
+++ test/std/input.output/iostreams.base/fpos/fpos.operations/offset.pass.cpp
@@ -15,10 +15,12 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(std::streamoff(7));
     std::streamoff offset(p);
     assert(offset == 7);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp
+++ test/std/input.output/iostreams.base/fpos/fpos.operations/streamsize.pass.cpp
@@ -13,11 +13,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::streamoff o(5);
     std::streamsize sz(o);
     assert(sz == 5);
     std::streamoff o2(sz);
     assert(o == o2);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp
+++ test/std/input.output/iostreams.base/fpos/fpos.operations/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::fpos<std::mbstate_t> P;
     P p(11);
@@ -24,4 +24,6 @@
     assert(q == P(5));
     p -= o;
     assert(p == q);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp
+++ test/std/input.output/iostreams.base/fpos/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags.pass.cpp
@@ -25,8 +25,10 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     const test t;
     assert(t.flags() == (test::skipws | test::dec));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/fmtflags.state/flags_fmtflags.pass.cpp
@@ -25,11 +25,13 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.flags() == (test::skipws | test::dec));
     test::fmtflags f = t.flags(test::hex | test::right);
     assert(f == (test::skipws | test::dec));
     assert(t.flags() == (test::hex | test::right));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision.pass.cpp
@@ -25,8 +25,10 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     const test t;
     assert(t.precision() == 6);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/fmtflags.state/precision_streamsize.pass.cpp
@@ -25,11 +25,13 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.precision() == 6);
     std::streamsize p = t.precision(10);
     assert(p == 6);
     assert(t.precision() == 10);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags.pass.cpp
@@ -25,11 +25,13 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.flags() == (test::skipws | test::dec));
     test::fmtflags f = t.setf(test::hex | test::right);
     assert(f == (test::skipws | test::dec));
     assert(t.flags() == (test::skipws | test::dec | test::hex | test::right));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/fmtflags.state/setf_fmtflags_mask.pass.cpp
@@ -25,11 +25,13 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.flags() == (test::skipws | test::dec));
     test::fmtflags f = t.setf(test::hex | test::right, test::dec | test::right);
     assert(f == (test::skipws | test::dec));
     assert(t.flags() == (test::skipws | test::right));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/fmtflags.state/unsetf_mask.pass.cpp
@@ -25,10 +25,12 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.flags() == (test::skipws | test::dec));
     t.unsetf(test::dec | test::right);
     assert(t.flags() == test::skipws);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/fmtflags.state/width.pass.cpp
@@ -25,8 +25,10 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     const test t;
     assert(t.width() == 0);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/fmtflags.state/width_streamsize.pass.cpp
@@ -25,11 +25,13 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.width() == 0);
     std::streamsize w = t.width(4);
     assert(w == 0);
     assert(t.width() == 4);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.base.callback/register_callback.pass.cpp
@@ -43,7 +43,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test t;
     std::ios_base& b = t;
@@ -52,4 +52,6 @@
     b.register_callback(f1, 4);
     std::locale l = b.imbue(std::locale(LOCALE_en_US_UTF_8));
     assert(f1_called == 3);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.base.cons/dtor.pass.cpp
@@ -70,7 +70,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -82,4 +82,6 @@
     assert(f1_called);
     assert(f2_called);
     assert(f3_called);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.base.locales/getloc.pass.cpp
@@ -26,8 +26,10 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     const test t;
     assert(t.getloc().name() == std::string("C"));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.base.locales/imbue.pass.cpp
@@ -74,7 +74,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test t;
     std::ios_base& b = t;
@@ -87,4 +87,6 @@
     assert(f1_called);
     assert(f2_called);
     assert(f3_called);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.base.storage/iword.pass.cpp
@@ -29,7 +29,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     std::ios_base& b = t;
@@ -41,4 +41,6 @@
         for (int j = 0; j <= i; ++j)
             assert(b.iword(j) == j);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.base.storage/pword.pass.cpp
@@ -30,7 +30,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     std::ios_base& b = t;
@@ -42,4 +42,6 @@
         for (std::intptr_t j = 0; j <= i; ++j)
             assert(b.pword(j) == (void*)j);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.base.storage/xalloc.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::xalloc() == 0);
     assert(std::ios_base::xalloc() == 1);
     assert(std::ios_base::xalloc() == 2);
     assert(std::ios_base::xalloc() == 3);
     assert(std::ios_base::xalloc() == 4);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.members.static/sync_with_stdio.pass.cpp
@@ -13,7 +13,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert( std::ios_base::sync_with_stdio(false));
     assert(!std::ios_base::sync_with_stdio(false));
@@ -23,4 +23,6 @@
     assert( std::ios_base::sync_with_stdio(false));
     assert(!std::ios_base::sync_with_stdio());
     assert( std::ios_base::sync_with_stdio());
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.types/ios_Init/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_char_pointer_error_code.pass.cpp
@@ -17,7 +17,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::string what_arg("io test message");
@@ -37,4 +37,6 @@
         assert(what_message.find(std::iostream_category().message(static_cast<int>
             (std::io_errc::stream))) != std::string::npos);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.types/ios_failure/ctor_string_error_code.pass.cpp
@@ -17,7 +17,7 @@
 #include <system_error>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     // LWG2462 std::ios_base::failure is overspecified
     static_assert((std::is_base_of<std::system_error, std::ios_base::failure>::value), "");
@@ -40,4 +40,6 @@
         assert(what_message.find(std::iostream_category().message(static_cast<int>
             (std::io_errc::stream))) != std::string::npos);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.types/ios_fmtflags/fmtflags.pass.cpp
@@ -32,7 +32,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::boolalpha);
     assert(std::ios_base::dec);
@@ -77,4 +77,6 @@
                                       | std::ios_base::hex));
     assert(std::ios_base::floatfield == (std::ios_base::scientific
                                        | std::ios_base::fixed));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.types/ios_iostate/iostate.pass.cpp
@@ -18,7 +18,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::badbit);
     assert(std::ios_base::eofbit);
@@ -32,4 +32,6 @@
     );
 
     assert(std::ios_base::goodbit == 0);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.types/ios_openmode/openmode.pass.cpp
@@ -20,7 +20,7 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::app);
     assert(std::ios_base::ate);
@@ -38,4 +38,6 @@
         & std::ios_base::out
         & std::ios_base::trunc) == 0
     );
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.types/ios_seekdir/seekdir.pass.cpp
@@ -17,9 +17,11 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::ios_base::beg != std::ios_base::cur);
     assert(std::ios_base::beg != std::ios_base::end);
     assert(std::ios_base::cur != std::ios_base::end);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/ios.types/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp
+++ test/std/input.output/iostreams.base/ios.base/nothing_to_do.pass.cpp
@@ -10,6 +10,8 @@
 
 #include <ios>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.cons/ctor_streambuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <streambuf>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::streambuf* sb = 0;
@@ -44,4 +44,6 @@
         assert(ios.fill() == ' ');
         assert(ios.getloc() == std::locale());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp
@@ -110,7 +110,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     testbuf sb1;
     std::ios ios1(&sb1);
@@ -190,4 +190,6 @@
     assert(ios1.tie() == (std::ostream*)2);
     assert(ios1.fill() == '2');
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/fill.pass.cpp
@@ -15,8 +15,10 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::ios ios(0);
     assert(ios.fill() == ' ');
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/fill_char_type.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(ios.fill() == ' ');
     char c = ios.fill('*');
     assert(c == ' ');
     assert(ios.fill() == '*');
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/imbue.pass.cpp
@@ -68,7 +68,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -99,4 +99,6 @@
         assert(f2_called);
         assert(f3_called);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/move.pass.cpp
@@ -77,7 +77,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     testios ios1;
     testbuf sb2;
@@ -136,4 +136,6 @@
 
     assert(ios2.rdbuf() == &sb2);
     assert(ios2.tie() == 0);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/narrow.pass.cpp
@@ -15,9 +15,11 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::wios ios(0);
     assert(ios.narrow(L'c', '*') == 'c');
     assert(ios.narrow(L'\u203C', '*') == '*');
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <streambuf>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::ios ios(0);
@@ -27,4 +27,6 @@
         const std::ios ios(sb);
         assert(ios.rdbuf() == sb);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/rdbuf_streambuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <streambuf>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(ios.rdbuf() == 0);
@@ -30,4 +30,6 @@
     assert(sb2 == (std::streambuf*)1);
     assert(ios.rdbuf() == 0);
     assert(ios.bad());
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp
@@ -30,7 +30,7 @@
     void set_rdbuf(std::streambuf* x) {std::ios::set_rdbuf(x);}
 };
 
-int main()
+int main(int, char**)
 {
     testbuf sb1;
     testbuf sb2;
@@ -60,4 +60,6 @@
 #endif
     ios.set_rdbuf(0);
     assert(ios.rdbuf() == 0);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/swap.pass.cpp
@@ -70,7 +70,7 @@
     g3_called = true;
 }
 
-int main()
+int main(int, char**)
 {
     testbuf sb1;
     testios ios1(&sb1);
@@ -164,4 +164,6 @@
     ios2.imbue(std::locale("C"));
     assert(f1_called);
     assert(f2_called);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/tie.pass.cpp
@@ -15,8 +15,10 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::basic_ios<char> ios(0);
     assert(ios.tie() == 0);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/tie_ostream.pass.cpp
@@ -15,11 +15,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ostream* os = (std::ostream*)1;
     std::ostream* r = ios.tie(os);
     assert(r == 0);
     assert(ios.tie() == os);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp
+++ test/std/input.output/iostreams.base/ios/basic.ios.members/widen.pass.cpp
@@ -15,8 +15,10 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::ios ios(0);
     assert(ios.widen('c') == 'c');
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/bad.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -37,4 +37,6 @@
         ios.setstate(std::ios::badbit);
         assert(ios.bad());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(static_cast<bool>(ios) == !ios.fail());
@@ -30,4 +30,6 @@
 #if TEST_STD_VER >= 11
     static_assert((!std::is_convertible<std::ios, bool>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp
@@ -20,7 +20,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -66,4 +66,6 @@
         ios.clear(std::ios::eofbit);
         assert(ios.rdstate() == std::ios::eofbit);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/eof.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -33,4 +33,6 @@
         ios.setstate(std::ios::eofbit);
         assert(ios.eof());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/exceptions.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         const std::ios ios(0);
@@ -29,4 +29,6 @@
         const std::ios ios(&sb);
         assert(ios.exceptions() == std::ios::goodbit);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.pass.cpp
@@ -20,7 +20,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -48,4 +48,6 @@
         ios.exceptions(std::ios::badbit);
         assert(ios.exceptions() == std::ios::badbit);
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/fail.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -37,4 +37,6 @@
         ios.setstate(std::ios::failbit);
         assert(ios.fail());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/good.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -31,4 +31,6 @@
         ios.setstate(std::ios::eofbit);
         assert(!ios.good());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/not.pass.cpp
@@ -15,10 +15,12 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(!ios == ios.fail());
     ios.setstate(std::ios::failbit);
     assert(!ios == ios.fail());
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/rdstate.pass.cpp
@@ -15,10 +15,12 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     assert(ios.rdstate() == std::ios::badbit);
     ios.setstate(std::ios::failbit);
     assert(ios.rdstate() == (std::ios::failbit | std::ios::badbit));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp
+++ test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp
@@ -20,7 +20,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     {
         std::ios ios(0);
@@ -65,4 +65,6 @@
         ios.setstate(std::ios::failbit);
         assert(ios.rdstate() == (std::ios::eofbit | std::ios::failbit));
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/ios/types.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/ios/types.pass.cpp
+++ test/std/input.output/iostreams.base/ios/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::ios_base, std::basic_ios<char> >::value), "");
     static_assert((std::is_same<std::basic_ios<char>::char_type, char>::value), "");
@@ -29,4 +29,6 @@
     static_assert((std::is_same<std::basic_ios<char>::int_type, std::char_traits<char>::int_type>::value), "");
     static_assert((std::is_same<std::basic_ios<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ios<char>::off_type, std::char_traits<char>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
+++ test/std/input.output/iostreams.base/is_error_code_enum_io_errc.pass.cpp
@@ -15,10 +15,12 @@
 #include <ios>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_error_code_enum  <std::io_errc>::value, "");
 #if TEST_STD_VER > 14
     static_assert(std::is_error_code_enum_v<std::io_errc>, "");
 #endif
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/internal.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::internal(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::internal);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/left.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::left(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::left);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/adjustfield.manip/right.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::right(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::right);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/dec.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::dec(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::dec);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/hex.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::hex(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::hex);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/basefield.manip/oct.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::oct(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::oct);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/error.reporting/iostream_category.pass.cpp
@@ -14,9 +14,11 @@
 #include <cassert>
 #include <string>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat1 = std::iostream_category();
     std::string m1 = e_cat1.name();
     assert(m1 == "iostream");
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_code.pass.cpp
@@ -13,11 +13,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec = make_error_code(std::io_errc::stream);
         assert(ec.value() == static_cast<int>(std::io_errc::stream));
         assert(ec.category() == std::iostream_category());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/error.reporting/make_error_condition.pass.cpp
@@ -13,11 +13,13 @@
 #include <ios>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec1 = std::make_error_condition(std::io_errc::stream);
         assert(ec1.value() == static_cast<int>(std::io_errc::stream));
         assert(ec1.category() == std::iostream_category());
     }
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/defaultfloat.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::fixed));
     assert(!(ios.flags() & std::ios::scientific));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/fixed.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::fixed(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::fixed);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/hexfloat.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@
     assert(&r == &ios);
     assert(ios.flags() & std::ios::fixed);
     assert(ios.flags() & std::ios::scientific);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/floatfield.manip/scientific.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::scientific(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::scientific);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/boolalpha.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::boolalpha(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::boolalpha);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noboolalpha.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@
     std::ios_base& r = std::noboolalpha(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::boolalpha));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowbase.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@
     std::ios_base& r = std::noshowbase(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::showbase));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpoint.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@
     std::ios_base& r = std::noshowpoint(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::showpoint));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noshowpos.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@
     std::ios_base& r = std::noshowpos(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::showpos));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/noskipws.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@
     std::ios_base& r = std::noskipws(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::skipws));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nounitbuf.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@
     std::ios_base& r = std::nounitbuf(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::unitbuf));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/nouppercase.pass.cpp
@@ -18,7 +18,7 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
@@ -26,4 +26,6 @@
     std::ios_base& r = std::nouppercase(ios);
     assert(&r == &ios);
     assert(!(ios.flags() & std::ios::uppercase));
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showbase.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::showbase(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::showbase);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpoint.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::showpoint(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::showpoint);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/showpos.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::showpos(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::showpos);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/skipws.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::skipws(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::skipws);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/unitbuf.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::unitbuf(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::unitbuf);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/fmtflags.manip/uppercase.pass.cpp
@@ -18,11 +18,13 @@
 
 struct testbuf : public std::streambuf {};
 
-int main()
+int main(int, char**)
 {
     testbuf sb;
     std::ios ios(&sb);
     std::ios_base& r = std::uppercase(ios);
     assert(&r == &ios);
     assert(ios.flags() & std::ios::uppercase);
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp
+++ test/std/input.output/iostreams.base/std.ios.manip/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp
+++ test/std/input.output/iostreams.base/stream.types/streamoff.pass.cpp
@@ -13,8 +13,10 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_integral<std::streamoff>::value, "");
     static_assert(std::is_signed<std::streamoff>::value, "");
+
+  return 0;
 }
Index: test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp
===================================================================
--- test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp
+++ test/std/input.output/iostreams.base/stream.types/streamsize.pass.cpp
@@ -13,8 +13,10 @@
 #include <ios>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_integral<std::streamsize>::value, "");
     static_assert(std::is_signed<std::streamsize>::value, "");
+
+  return 0;
 }
Index: test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp
===================================================================
--- test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp
+++ test/std/input.output/iostreams.requirements/iostream.limits.imbue/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp
+++ test/std/input.output/iostreams.requirements/iostreams.limits.pos/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp
+++ test/std/input.output/iostreams.requirements/iostreams.threadsafety/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp
+++ test/std/input.output/iostreams.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/nothing_to_do.pass.cpp
+++ test/std/input.output/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf.reqts/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.fail.cpp
@@ -18,7 +18,9 @@
 
 std::streambuf &get();
 
-int main()
+int main(int, char**)
 {
     std::streambuf sb = get(); // expected-error {{calling a protected constructor}}
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.cons/copy.pass.cpp
@@ -49,7 +49,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -82,4 +82,6 @@
         test<wchar_t> t;
         test<wchar_t> t2 = t;
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.fail.cpp
@@ -15,7 +15,9 @@
 
 #include <streambuf>
 
-int main()
+int main(int, char**)
 {
     std::basic_streambuf<char> sb;
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.cons/default.pass.cpp
@@ -35,7 +35,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -54,4 +54,6 @@
         test<wchar_t> t;
         assert(t.getloc().name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekoff.pass.cpp
@@ -24,11 +24,13 @@
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
         assert(t.pubseekoff(0, std::ios_base::beg) == -1);
         assert(t.pubseekoff(0, std::ios_base::beg, std::ios_base::app) == -1);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubseekpos.pass.cpp
@@ -24,10 +24,12 @@
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
         assert(t.pubseekpos(0, std::ios_base::app) == -1);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsetbuf.pass.cpp
@@ -23,10 +23,12 @@
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
         assert(t.pubsetbuf(0, 0) == &t);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.buffer/pubsync.pass.cpp
@@ -23,10 +23,12 @@
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
         assert(t.pubsync() == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.locales/locales.pass.cpp
@@ -34,7 +34,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -48,4 +48,6 @@
                LOCALE_en_US_UTF_8);
         assert(t.getloc().name() == LOCALE_fr_FR_UTF_8);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/in_avail.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -48,4 +48,6 @@
         t.setg(in, in+2, in+5);
         assert(t.in_avail() == 3);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sbumpc.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@
         assert(t.sbumpc() == 'B');
         assert(uflow_called == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetc.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@
         assert(t.sgetc() == 'A');
         assert(underflow_called == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/sgetn.pass.cpp
@@ -31,10 +31,12 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(xsgetn_called == 0);
     assert(t.sgetn(0, 0) == 10);
     assert(xsgetn_called == 1);
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.get/snextc.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@
         assert(t.snextc() == 'C');
         assert(uflow_called == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sputbackc.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@
         assert(t.sputbackc('A') == 'a');
         assert(pbackfail_called == 2);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.pback/sungetc.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -52,4 +52,6 @@
         assert(t.sungetc() == 'a');
         assert(pbackfail_called == 2);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputc.pass.cpp
@@ -42,7 +42,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -59,4 +59,6 @@
         assert(out[0] == 'A');
         assert(out[1] == 'B');
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.members/streambuf.pub.put/sputn.pass.cpp
@@ -31,10 +31,12 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(xsputn_called == 0);
     assert(t.sputn(0, 0) == 5);
     assert(xsputn_called == 1);
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.protected/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/assign.pass.cpp
@@ -50,7 +50,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -89,4 +89,6 @@
         test<wchar_t> t2;
         t2 = t;
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp
@@ -59,7 +59,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -98,4 +98,6 @@
         test<wchar_t> t2;
         t2.swap(t);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/gbump.pass.cpp
@@ -41,7 +41,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -55,4 +55,6 @@
         t.setg(in, in+1, in+sizeof(in)/sizeof(in[0]));
         t.gbump(3);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.get.area/setg.pass.cpp
@@ -33,7 +33,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -45,4 +45,6 @@
         wchar_t in[] = L"ABC";
         t.setg(in, in+1, in+sizeof(in)/sizeof(in[0]));
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump.pass.cpp
@@ -41,7 +41,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -57,4 +57,6 @@
         t.pbump(3);
         t.pbump(1);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
@@ -26,7 +26,7 @@
   const char* pubpptr() const { return pptr(); }
 };
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try {
@@ -40,4 +40,6 @@
     catch (const std::length_error &) {} // maybe the string can't take 2GB
     catch (const std::bad_alloc    &) {} // maybe we don't have enough RAM
 #endif
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/setp.pass.cpp
@@ -33,7 +33,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test<char> t;
@@ -45,4 +45,6 @@
         wchar_t in[] = L"ABC";
         t.setp(in, in+sizeof(in)/sizeof(in[0]));
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.buffer/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/showmanyc.pass.cpp
@@ -25,8 +25,10 @@
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     test<char> t;
     assert(t.in_avail() == 0);
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/uflow.pass.cpp
@@ -25,8 +25,10 @@
 
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.sgetc() == -1);
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/underflow.pass.cpp
@@ -22,8 +22,10 @@
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.sgetc() == -1);
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.get/xsgetn.pass.cpp
@@ -30,7 +30,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     char input[7] = "123456";
@@ -38,4 +38,6 @@
     char output[sizeof(input)] = {0};
     assert(t.sgetn(output, 10) == 7);
     assert(std::strcmp(input, output) == 0);
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.locales/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.pback/pbackfail.pass.cpp
@@ -24,8 +24,10 @@
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.sputbackc('A') == -1);
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/overflow.pass.cpp
@@ -22,8 +22,10 @@
     test() {}
 };
 
-int main()
+int main(int, char**)
 {
     test t;
     assert(t.sputc('A') == -1);
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.pass.cpp
@@ -30,7 +30,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         test t;
@@ -41,4 +41,6 @@
         assert(t.sputn(in, sizeof(in)) == sizeof(in));
         assert(std::strcmp(in, out) == 0);
     }
+
+  return 0;
 }
Index: test/std/input.output/stream.buffers/streambuf/types.pass.cpp
===================================================================
--- test/std/input.output/stream.buffers/streambuf/types.pass.cpp
+++ test/std/input.output/stream.buffers/streambuf/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <streambuf>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::streambuf::char_type, char>::value), "");
     static_assert((std::is_same<std::streambuf::traits_type, std::char_traits<char> >::value), "");
@@ -35,4 +35,6 @@
     static_assert((std::is_same<std::wstreambuf::int_type, std::char_traits<wchar_t>::int_type>::value), "");
     static_assert((std::is_same<std::wstreambuf::pos_type, std::char_traits<wchar_t>::pos_type>::value), "");
     static_assert((std::is_same<std::wstreambuf::off_type, std::char_traits<wchar_t>::off_type>::value), "");
+
+  return 0;
 }
Index: test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp
+++ test/std/input.output/string.streams/istringstream/istringstream.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss0(" 123 456");
@@ -52,4 +52,6 @@
         ss0 >> i;
         assert(i == 321);
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp
===================================================================
--- test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp
+++ test/std/input.output/string.streams/istringstream/istringstream.assign/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss0(" 123 456");
@@ -82,4 +82,6 @@
         s1 >> s;
         assert(s == L"Dddddddddddddddddd");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp
===================================================================
--- test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp
+++ test/std/input.output/string.streams/istringstream/istringstream.assign/nonmember_swap.pass.cpp
@@ -19,7 +19,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss0(" 123 456");
@@ -55,4 +55,6 @@
         ss0 >> i;
         assert(i == 321);
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp
===================================================================
--- test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp
+++ test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss;
@@ -42,4 +42,6 @@
         assert(ss.good());
         assert(ss.str() == L"");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp
===================================================================
--- test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp
+++ test/std/input.output/string.streams/istringstream/istringstream.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss0(" 123 456");
@@ -44,4 +44,6 @@
         ss >> i;
         assert(i == 456);
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp
===================================================================
--- test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp
+++ test/std/input.output/string.streams/istringstream/istringstream.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss(" 123 456");
@@ -63,4 +63,6 @@
         ss >> i;
         assert(i == 456);
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp
===================================================================
--- test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp
+++ test/std/input.output/string.streams/istringstream/istringstream.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream ss(" 123 456");
@@ -52,4 +52,6 @@
         ss >> i;
         assert(i == 789);
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/istringstream/types.pass.cpp
===================================================================
--- test/std/input.output/string.streams/istringstream/types.pass.cpp
+++ test/std/input.output/string.streams/istringstream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <sstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_istream<char>, std::basic_istringstream<char> >::value), "");
     static_assert((std::is_same<std::basic_istringstream<char>::char_type, char>::value), "");
@@ -32,4 +32,6 @@
     static_assert((std::is_same<std::basic_istringstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_istringstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
     static_assert((std::is_same<std::basic_istringstream<char>::allocator_type, std::allocator<char> >::value), "");
+
+  return 0;
 }
Index: test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp
+++ test/std/input.output/string.streams/ostringstream/ostringstream.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss0(" 123 456");
@@ -44,4 +44,6 @@
         ss0 << i << ' ' << 567;
         assert(ss0.str() == L"234 567");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp
===================================================================
--- test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp
+++ test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss0(" 123 456");
@@ -42,4 +42,6 @@
         ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp
===================================================================
--- test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp
+++ test/std/input.output/string.streams/ostringstream/ostringstream.assign/nonmember_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss0(" 123 456");
@@ -44,4 +44,6 @@
         ss0 << i << ' ' << 567;
         assert(ss0.str() == L"234 567");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp
===================================================================
--- test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp
+++ test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss;
@@ -42,4 +42,6 @@
         assert(ss.good());
         assert(ss.str() == L"");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp
===================================================================
--- test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp
+++ test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss0(" 123 456");
@@ -40,4 +40,6 @@
         ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp
===================================================================
--- test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp
+++ test/std/input.output/string.streams/ostringstream/ostringstream.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss(" 123 456");
@@ -55,4 +55,6 @@
         ss << i << ' ' << 567;
         assert(ss.str() == L"234 5676");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp
===================================================================
--- test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp
+++ test/std/input.output/string.streams/ostringstream/ostringstream.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream ss(" 123 456");
@@ -48,4 +48,6 @@
         ss << L"abc";
         assert(ss.str() == L"abc9");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/ostringstream/types.pass.cpp
===================================================================
--- test/std/input.output/string.streams/ostringstream/types.pass.cpp
+++ test/std/input.output/string.streams/ostringstream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <sstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_ostream<char>, std::basic_ostringstream<char> >::value), "");
     static_assert((std::is_same<std::basic_ostringstream<char>::char_type, char>::value), "");
@@ -32,4 +32,6 @@
     static_assert((std::is_same<std::basic_ostringstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_ostringstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
     static_assert((std::is_same<std::basic_ostringstream<char>::allocator_type, std::allocator<char> >::value), "");
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf1("testing");
@@ -60,4 +60,6 @@
         assert(buf.str() == L"testing");
         assert(buf1.str() == L"");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.assign/move.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf1("testing");
@@ -54,4 +54,6 @@
         buf = move(buf1);
         assert(buf.str() == L"testing");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.assign/nonmember_swap.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf1("testing");
@@ -62,4 +62,6 @@
         assert(buf.str() == L"testing");
         assert(buf1.str() == L"");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
@@ -31,7 +31,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf;
@@ -49,4 +49,6 @@
         testbuf<wchar_t> buf;
         buf.check();
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf1("testing");
@@ -48,4 +48,6 @@
         std::wstringbuf buf(move(buf1));
         assert(buf.str() == L"testing");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.cons/string.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf("testing");
@@ -43,4 +43,6 @@
         std::wstringbuf buf(L"testing", std::ios_base::out);
         assert(buf.str() == L"testing");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf buf("testing");
@@ -30,4 +30,6 @@
         buf.str(L"another test");
         assert(buf.str() == L"another test");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/overflow.pass.cpp
@@ -34,7 +34,7 @@
     void pbump(int n) {base::pbump(n);}
 };
 
-int main()
+int main(int, char**)
 {
     {  // sanity check
     testbuf<char> tb("");
@@ -97,4 +97,6 @@
         assert(sb.sputc('2') == '2');
         assert(sb.str() == "abc12");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/pbackfail.pass.cpp
@@ -32,7 +32,7 @@
     void pbump(int n) {base::pbump(n);}
 };
 
-int main()
+int main(int, char**)
 {
     {  // sanity check
     testbuf<char> tb("");
@@ -92,4 +92,6 @@
         assert(sb.pbackfail(std::char_traits<wchar_t>::eof()) == std::char_traits<wchar_t>::eof());
         assert(sb.str() == L"133");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekoff.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf sb(std::ios_base::in);
@@ -163,4 +163,6 @@
         assert(sb.sputc(L'c') == L'c');
         assert(sb.str() == L"0123456c89");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/seekpos.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf sb("0123456789", std::ios_base::in);
@@ -73,4 +73,6 @@
         assert(sb.sputc(L'3') == L'3');
         assert(sb.str() == L"0123456789");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/setbuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringbuf sb("0123456789");
@@ -28,4 +28,6 @@
         assert(sb.pubsetbuf(0, 0) == &sb);
         assert(sb.str() == L"0123456789");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/stringbuf.virtuals/underflow.pass.cpp
@@ -28,7 +28,7 @@
     void pbump(int n) {base::pbump(n);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         testbuf<char> sb("123");
@@ -66,4 +66,6 @@
         assert(sb.underflow() == L'4');
         assert(sb.underflow() == L'4');
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringbuf/types.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringbuf/types.pass.cpp
+++ test/std/input.output/string.streams/stringbuf/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <sstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_streambuf<char>, std::basic_stringbuf<char> >::value), "");
     static_assert((std::is_same<std::basic_stringbuf<char>::char_type, char>::value), "");
@@ -32,4 +32,6 @@
     static_assert((std::is_same<std::basic_stringbuf<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_stringbuf<char>::off_type, std::char_traits<char>::off_type>::value), "");
     static_assert((std::is_same<std::basic_stringbuf<char>::allocator_type, std::allocator<char> >::value), "");
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringstream.cons/default.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringstream.cons/default.pass.cpp
+++ test/std/input.output/string.streams/stringstream.cons/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss;
@@ -42,4 +42,6 @@
         assert(ss.good());
         assert(ss.str() == L"");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringstream.cons/move.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringstream.cons/move.pass.cpp
+++ test/std/input.output/string.streams/stringstream.cons/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
@@ -48,4 +48,6 @@
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp
+++ test/std/input.output/string.streams/stringstream.cons/move2.pass.cpp
@@ -21,7 +21,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     std::vector<std::istringstream> vecis;
     vecis.push_back(std::istringstream());
@@ -34,4 +34,6 @@
         vecis[n].seekg(0, std::ios_base::beg);
         assert(vecis[n].str().size() == 31);
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
+++ test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
@@ -27,7 +27,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss(" 123 456 ");
@@ -64,4 +64,6 @@
     //  This test is not required by the standard, but *where else* could it get the allocator?
         assert(sb.str().get_allocator() == s.get_allocator());
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp
+++ test/std/input.output/string.streams/stringstream.cons/stringstream.assign/member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
@@ -52,4 +52,6 @@
         ss0 << i << ' ' << 123;
         assert(ss0.str() == L"456 123");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp
+++ test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
@@ -50,4 +50,6 @@
         ss << i << ' ' << 123;
         assert(ss.str() == L"456 1236 ");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp
+++ test/std/input.output/string.streams/stringstream.cons/stringstream.assign/nonmember_swap.pass.cpp
@@ -19,7 +19,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss0(" 123 456 ");
@@ -55,4 +55,6 @@
         ss0 << i << ' ' << 123;
         assert(ss0.str() == L"456 123");
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringstream.members/str.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringstream.members/str.pass.cpp
+++ test/std/input.output/string.streams/stringstream.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::stringstream ss(" 123 456 ");
@@ -63,4 +63,6 @@
         ss.write("\xd1", 1);
         assert(ss.str().length() == 1);
     }
+
+  return 0;
 }
Index: test/std/input.output/string.streams/stringstream/types.pass.cpp
===================================================================
--- test/std/input.output/string.streams/stringstream/types.pass.cpp
+++ test/std/input.output/string.streams/stringstream/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <sstream>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::basic_iostream<char>, std::basic_stringstream<char> >::value), "");
     static_assert((std::is_same<std::basic_stringstream<char>::char_type, char>::value), "");
@@ -32,4 +32,6 @@
     static_assert((std::is_same<std::basic_stringstream<char>::pos_type, std::char_traits<char>::pos_type>::value), "");
     static_assert((std::is_same<std::basic_stringstream<char>::off_type, std::char_traits<char>::off_type>::value), "");
     static_assert((std::is_same<std::basic_stringstream<char>::allocator_type, std::allocator<char> >::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.container/data.pass.cpp
===================================================================
--- test/std/iterators/iterator.container/data.pass.cpp
+++ test/std/iterators/iterator.container/data.pass.cpp
@@ -61,7 +61,7 @@
     assert ( std::data(array) == &array[0]);
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v; v.push_back(1);
     std::array<int, 1> a; a[0] = 3;
@@ -83,4 +83,6 @@
 
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
+
+  return 0;
 }
Index: test/std/iterators/iterator.container/empty.array.fail.cpp
===================================================================
--- test/std/iterators/iterator.container/empty.array.fail.cpp
+++ test/std/iterators/iterator.container/empty.array.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     int c[5];
     std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/iterators/iterator.container/empty.container.fail.cpp
===================================================================
--- test/std/iterators/iterator.container/empty.container.fail.cpp
+++ test/std/iterators/iterator.container/empty.container.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::vector<int> c;
     std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
===================================================================
--- test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
+++ test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::initializer_list<int> c = { 4 };
     std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/iterators/iterator.container/empty.pass.cpp
===================================================================
--- test/std/iterators/iterator.container/empty.pass.cpp
+++ test/std/iterators/iterator.container/empty.pass.cpp
@@ -60,7 +60,7 @@
     assert (!std::empty(array));
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v; v.push_back(1);
     std::list<int>   l; l.push_back(2);
@@ -85,4 +85,6 @@
 
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
+
+  return 0;
 }
Index: test/std/iterators/iterator.container/size.pass.cpp
===================================================================
--- test/std/iterators/iterator.container/size.pass.cpp
+++ test/std/iterators/iterator.container/size.pass.cpp
@@ -63,7 +63,7 @@
     assert ( std::size(array) == Sz );
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<int> v; v.push_back(1);
     std::list<int>   l; l.push_back(2);
@@ -87,4 +87,6 @@
 
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp
@@ -72,10 +72,12 @@
     static_assert((std::is_same<typename It::iterator_category, std::input_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test2<A>();
     test3<A>();
     test4<A>();
     test5<A>();
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
@@ -42,7 +42,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "1234567890";
@@ -68,4 +68,6 @@
     static_assert( constepxr_test(s+5, -5, s), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
@@ -37,7 +37,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "1234567890";
@@ -57,4 +57,6 @@
     static_assert( constexpr_test(s, s+10, 10), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
@@ -51,7 +51,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "1234567890";
@@ -83,4 +83,6 @@
     static_assert( constexpr_test(s, s+1), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
@@ -49,7 +49,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "1234567890";
@@ -74,4 +74,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
@@ -23,7 +23,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<const A*> It;
     static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
@@ -31,4 +31,6 @@
     static_assert((std::is_same<It::pointer, const A*>::value), "");
     static_assert((std::is_same<It::reference, const A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
@@ -16,7 +16,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<const volatile A*> It;
     static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
@@ -24,4 +24,6 @@
     static_assert((std::is_same<It::pointer, const volatile A*>::value), "");
     static_assert((std::is_same<It::reference, const volatile A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
+++ test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
@@ -63,7 +63,7 @@
 //     typedef std::forward_iterator_tag iterator_category;
 };
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::iterator_traits<NotAnIteratorEmpty> T;
@@ -118,4 +118,6 @@
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std::{{.+}}::iterator_traits<{{.+}}>}}
     }
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
@@ -30,8 +30,10 @@
     static const bool value = sizeof(test<T>(0)) == 1;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<not_an_iterator> It;
     static_assert(!(has_value_type<It>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.traits/iterator.pass.cpp
@@ -32,7 +32,7 @@
     typedef std::forward_iterator_tag iterator_category;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<test_iterator> It;
     static_assert((std::is_same<It::difference_type, int>::value), "");
@@ -40,4 +40,6 @@
     static_assert((std::is_same<It::pointer, A*>::value), "");
     static_assert((std::is_same<It::reference, A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::forward_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.traits/pointer.pass.cpp
@@ -23,7 +23,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<A*> It;
     static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
@@ -31,4 +31,6 @@
     static_assert((std::is_same<It::pointer, A*>::value), "");
     static_assert((std::is_same<It::reference, A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
+++ test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
@@ -16,7 +16,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     typedef std::iterator_traits<volatile A*> It;
     static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
@@ -24,4 +24,6 @@
     static_assert((std::is_same<It::pointer, volatile A*>::value), "");
     static_assert((std::is_same<It::reference, volatile A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.primitives/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
+++ test/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp
@@ -13,7 +13,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::bidirectional_iterator_tag tag;
     ((void)tag); // Prevent unused warning
@@ -21,4 +21,6 @@
                                    std::bidirectional_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::bidirectional_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
+++ test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp
@@ -13,7 +13,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::forward_iterator_tag tag;
     ((void)tag); // Prevent unused warning
@@ -21,4 +21,6 @@
                                    std::forward_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::forward_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
+++ test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp
@@ -13,10 +13,12 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::input_iterator_tag tag;
     ((void)tag); // Prevent unused warning
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::input_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
+++ test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp
@@ -13,10 +13,12 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::output_iterator_tag tag;
     ((void)tag); // Prevent unused warning
     static_assert((!std::is_base_of<std::input_iterator_tag,
                                     std::output_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
===================================================================
--- test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
+++ test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp
@@ -13,7 +13,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::random_access_iterator_tag tag;
     ((void)tag); // Prevent unused warning
@@ -21,4 +21,6 @@
                                    std::random_access_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::random_access_iterator_tag>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/iterator.range/begin-end.fail.cpp
===================================================================
--- test/std/iterators/iterator.range/begin-end.fail.cpp
+++ test/std/iterators/iterator.range/begin-end.fail.cpp
@@ -40,11 +40,13 @@
 }
 
 
-int main(){
+int main(int, char**) {
 // Bug #28927 - shouldn't find these via ADL
     TEST_IGNORE_NODISCARD  std::cbegin (Foo::FakeContainer());
     TEST_IGNORE_NODISCARD  std::cend   (Foo::FakeContainer());
     TEST_IGNORE_NODISCARD  std::crbegin(Foo::FakeContainer());
     TEST_IGNORE_NODISCARD  std::crend  (Foo::FakeContainer());
+
+  return 0;
 }
 #endif
Index: test/std/iterators/iterator.range/begin-end.pass.cpp
===================================================================
--- test/std/iterators/iterator.range/begin-end.pass.cpp
+++ test/std/iterators/iterator.range/begin-end.pass.cpp
@@ -135,7 +135,7 @@
 #endif
     }
 
-int main(){
+int main(int, char**) {
     std::vector<int> v; v.push_back(1);
     std::list<int> l;   l.push_back(2);
     std::array<int, 1> a; a[0] = 3;
@@ -197,4 +197,6 @@
         static_assert ( *std::crbegin(c) == 4, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.requirements/bidirectional.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.requirements/forward.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.requirements/input.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.requirements/iterator.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.requirements/iterator.requirements.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.requirements/output.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.requirements/random.access.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp
+++ test/std/iterators/iterator.synopsis/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/iterators.general/gcc_workaround.pass.cpp
===================================================================
--- test/std/iterators/iterators.general/gcc_workaround.pass.cpp
+++ test/std/iterators/iterators.general/gcc_workaround.pass.cpp
@@ -17,4 +17,6 @@
 
 void AppendTo(const std::vector<char> &v) { TEST_IGNORE_NODISCARD v.begin(); }
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/iterators/iterators.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/iterators.general/nothing_to_do.pass.cpp
+++ test/std/iterators/iterators.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.fail.cpp
@@ -17,7 +17,9 @@
 #include <iterator>
 #include <vector>
 
-int main()
+int main(int, char**)
 {
     std::back_insert_iterator<std::vector<int> > i = std::vector<int>();
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.pass.cpp
@@ -23,8 +23,10 @@
     std::back_insert_iterator<C> i(c);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp
@@ -28,8 +28,10 @@
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp
@@ -26,8 +26,10 @@
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
@@ -39,7 +39,9 @@
         {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     test(std::vector<Copyable>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
@@ -31,7 +31,9 @@
     assert(c.back() == typename C::value_type());
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<std::unique_ptr<int> >());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp
@@ -26,8 +26,10 @@
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.inserter/test.pass.cpp
@@ -27,8 +27,10 @@
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp
@@ -52,7 +52,9 @@
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >();
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.fail.cpp
@@ -17,7 +17,9 @@
 #include <iterator>
 #include <list>
 
-int main()
+int main(int, char**)
 {
     std::front_insert_iterator<std::list<int> > i = std::list<int>();
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp
@@ -23,8 +23,10 @@
     std::front_insert_iterator<C> i(c);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp
@@ -28,8 +28,10 @@
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp
@@ -26,8 +26,10 @@
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp
@@ -39,8 +39,10 @@
         {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     test(std::list<Copyable>());
     test(nasty_list<Copyable>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp
@@ -29,7 +29,9 @@
     assert(c.front() == typename C::value_type());
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<std::unique_ptr<int> >());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp
@@ -26,8 +26,10 @@
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp
@@ -27,8 +27,10 @@
     assert(c.front() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp
@@ -53,7 +53,9 @@
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >();
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp
@@ -23,8 +23,10 @@
     std::insert_iterator<C> i(c, c.begin());
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp
@@ -28,8 +28,10 @@
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp
@@ -26,8 +26,10 @@
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
@@ -43,7 +43,7 @@
     c.insert(++i, x3);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::vector<int> C;
@@ -81,4 +81,6 @@
     insert3at(c2, c2.begin()+3, 'a', 'b', 'c');
     test(c1, 3, 'a', 'b', 'c', c2);
     }
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
@@ -52,7 +52,7 @@
     void operator()(void*) const {}
 };
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::unique_ptr<int, do_nothing> Ptr;
@@ -91,4 +91,6 @@
     insert3at(c2, c2.begin()+3, Ptr(x+3), Ptr(x+4), Ptr(x+5));
     test(std::move(c1), 3, Ptr(x+3), Ptr(x+4), Ptr(x+5), c2);
     }
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp
@@ -26,8 +26,10 @@
     assert(&r == &i);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp
@@ -27,8 +27,10 @@
     assert(c.back() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
@@ -58,7 +58,9 @@
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::vector<int> >();
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
@@ -30,7 +30,7 @@
     assert(std::make_move_iterator(i) == r);
 }
 
-int main()
+int main(int, char**)
 {
     {
     char s[] = "1234567890";
@@ -53,4 +53,6 @@
     static_assert(iter.base() == p);
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
@@ -33,7 +33,7 @@
     assert(r1 - r2 == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s+5), random_access_iterator<char*>(s), 5);
@@ -49,4 +49,6 @@
     static_assert( it2 - it1 ==  1, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
@@ -31,7 +31,7 @@
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s+5), 5, random_access_iterator<char*>(s+10));
@@ -49,4 +49,6 @@
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
@@ -30,7 +30,7 @@
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
@@ -48,4 +48,6 @@
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
@@ -31,7 +31,7 @@
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
@@ -49,4 +49,6 @@
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
@@ -30,7 +30,7 @@
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -48,4 +48,6 @@
     static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
@@ -31,7 +31,7 @@
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -45,4 +45,6 @@
     static_assert(it1 == it2, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 == r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(input_iterator<char*>(s), input_iterator<char*>(s), true);
@@ -58,4 +58,6 @@
     static_assert(!(it2 == it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 > r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
@@ -54,4 +54,6 @@
     static_assert( (it2 > it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 >= r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
@@ -54,4 +54,6 @@
     static_assert( (it2 >= it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 < r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
@@ -54,4 +54,6 @@
     static_assert(!(it2 < it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 <= r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
@@ -54,4 +54,6 @@
     static_assert(!(it2 <= it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 != r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "1234567890";
     test(input_iterator<char*>(s), input_iterator<char*>(s), false);
@@ -58,4 +58,6 @@
     static_assert( (it2 != it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.fail.cpp
@@ -29,9 +29,11 @@
 struct base {};
 struct derived {};
 
-int main()
+int main(int, char**)
 {
     derived d;
 
     test<base*>(&d);
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
@@ -34,7 +34,7 @@
 struct Base {};
 struct Derived : Base {};
 
-int main()
+int main(int, char**)
 {
     Derived d;
 
@@ -52,4 +52,6 @@
     static_assert(it2.base() == p);
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
@@ -27,7 +27,7 @@
     (void)r;
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<char*> >();
     test<forward_iterator<char*> >();
@@ -41,4 +41,6 @@
     (void)it;
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.fail.cpp
@@ -23,8 +23,10 @@
     std::move_iterator<It> r = i;
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(s);
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
@@ -28,7 +28,7 @@
     assert(r.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(input_iterator<char*>(s));
@@ -44,4 +44,6 @@
     static_assert(it.base() == p);
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
@@ -30,7 +30,7 @@
     assert(rr.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
@@ -49,4 +49,6 @@
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
@@ -30,7 +30,7 @@
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
@@ -49,4 +49,6 @@
     static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
@@ -30,7 +30,7 @@
     assert(rr.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(input_iterator<char*>(s), input_iterator<char*>(s+1));
@@ -51,4 +51,6 @@
     static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
@@ -30,7 +30,7 @@
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(input_iterator<char*>(s), input_iterator<char*>(s+1));
@@ -51,4 +51,6 @@
     static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
@@ -38,7 +38,7 @@
     void operator()(void*) const {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         char s[] = "1234567890";
@@ -64,4 +64,6 @@
     static_assert(it1[5] == '6', "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp
@@ -27,7 +27,7 @@
     assert(r.operator->() == i);
 }
 
-int main()
+int main(int, char**)
 {
     char s[] = "123";
     test(s);
@@ -42,4 +42,6 @@
     static_assert(it2.operator->() == p + 1, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp
@@ -47,7 +47,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         A a;
@@ -70,4 +70,6 @@
     static_assert(*it2 == p[1], "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.fail.cpp
@@ -31,8 +31,10 @@
 struct base {};
 struct derived {};
 
-int main()
+int main(int, char**)
 {
     derived d;
     test<base*>(&d);
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
@@ -37,7 +37,7 @@
 struct Base {};
 struct Derived : Base {};
 
-int main()
+int main(int, char**)
 {
     Derived d;
 
@@ -56,4 +56,6 @@
     static_assert(it2.base() == p, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iter.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
@@ -55,7 +55,7 @@
     static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<char*> >();
     test<forward_iterator<char*> >();
@@ -91,4 +91,6 @@
         static_assert(std::is_same<It::reference, int&&>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/move.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
@@ -27,7 +27,7 @@
     (void)r;
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<const char*> >();
     test<random_access_iterator<char*> >();
@@ -40,4 +40,6 @@
         (void)it;
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.fail.cpp
@@ -23,8 +23,10 @@
     std::reverse_iterator<It> r = i;
 }
 
-int main()
+int main(int, char**)
 {
     const char s[] = "123";
     test(s);
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
@@ -28,7 +28,7 @@
     assert(r.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     const char s[] = "123";
     test(bidirectional_iterator<const char*>(s));
@@ -42,4 +42,6 @@
         static_assert(it.base() == p);
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.fail.cpp
@@ -29,9 +29,11 @@
 struct base {};
 struct derived {};
 
-int main()
+int main(int, char**)
 {
     derived d;
 
     test<base*>(&d);
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
@@ -34,7 +34,7 @@
 struct Base {};
 struct Derived : Base {};
 
-int main()
+int main(int, char**)
 {
     Derived d;
 
@@ -50,4 +50,6 @@
         static_assert(it2.base() == p);
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.conv/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
@@ -31,7 +31,7 @@
     assert(r.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     random_access_iterator<const char*>b(s);
@@ -46,5 +46,7 @@
         static_assert(it1.base() == p, "");
     }
 #endif
+
+  return 0;
 }
 
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 != r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s), false);
@@ -53,4 +53,6 @@
         static_assert( (it1 != it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
@@ -30,7 +30,7 @@
     assert(rr.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "123";
     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
@@ -49,4 +49,6 @@
         static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
@@ -30,7 +30,7 @@
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "123";
     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
@@ -50,4 +50,6 @@
         static_assert(*(++std::make_reverse_iterator(p+2)) == '1', "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
@@ -30,7 +30,7 @@
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -48,4 +48,6 @@
         static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
@@ -31,7 +31,7 @@
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -45,4 +45,6 @@
         static_assert(it1 == it2, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
@@ -30,7 +30,7 @@
     assert(rr.base() == i);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "123";
     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s+2));
@@ -49,4 +49,6 @@
         static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
@@ -30,7 +30,7 @@
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "123";
     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s+2));
@@ -50,4 +50,6 @@
         static_assert(*(--std::make_reverse_iterator(p)) == '1', "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
@@ -30,7 +30,7 @@
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
@@ -48,4 +48,6 @@
         static_assert(it2 == it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
@@ -31,7 +31,7 @@
     assert(&rr == &r);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
@@ -45,4 +45,6 @@
         static_assert(it1 == it2, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
@@ -43,7 +43,7 @@
     assert(*r == x);
 }
 
-int main()
+int main(int, char**)
 {
     A a;
     test(&a+1, A());
@@ -58,4 +58,6 @@
         static_assert(*it2 == p[1], "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.fail.cpp
@@ -31,8 +31,10 @@
 struct base {};
 struct derived {};
 
-int main()
+int main(int, char**)
 {
     derived d;
     test<base*>(&d);
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
@@ -37,7 +37,7 @@
 struct Base {};
 struct Derived : Base {};
 
-int main()
+int main(int, char**)
 {
     Derived d;
 
@@ -55,4 +55,6 @@
         static_assert(it2.base() == p, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 == r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s), true);
@@ -54,4 +54,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
@@ -33,7 +33,7 @@
     assert((r1 - r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     char s[3] = {0};
     test(random_access_iterator<const char*>(s), random_access_iterator<char*>(s), 0);
@@ -53,4 +53,6 @@
         static_assert( it2 - it1 == -1, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 > r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), false);
@@ -53,4 +53,6 @@
         static_assert( (it1 > it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 >= r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), true);
@@ -53,4 +53,6 @@
         static_assert( (it1 >= it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
@@ -30,7 +30,7 @@
     assert(rr == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 4, '1');
@@ -45,4 +45,6 @@
     static_assert(it1[4] == '1', "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 < r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), false);
@@ -53,4 +53,6 @@
         static_assert(!(it1 < it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
@@ -32,7 +32,7 @@
     assert((r1 <= r2) == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), true);
@@ -53,4 +53,6 @@
         static_assert(!(it1 <= it3), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp
@@ -76,7 +76,7 @@
 
 TEST_CONSTEXPR  C gC;
 
-int main()
+int main(int, char**)
 {
     A a;
     test(&a+1, A());
@@ -115,4 +115,6 @@
     {
         ((void)gC);
     }
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
@@ -31,7 +31,7 @@
     assert(rr.base() == x);
 }
 
-int main()
+int main(int, char**)
 {
     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
@@ -49,4 +49,6 @@
         static_assert(it2 != it3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
+++ test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
@@ -52,9 +52,11 @@
     static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<bidirectional_iterator<char*> >();
     test<random_access_iterator<char*> >();
     test<char*>();
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/copy.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::istream_iterator<int> io;
@@ -36,4 +36,6 @@
         j = *i;
         assert(j == 1);
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.fail.cpp
@@ -19,7 +19,7 @@
 
 struct S { S(); }; // not constexpr
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -28,4 +28,6 @@
 #else
 #error "C++11 only test"
 #endif
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
@@ -42,7 +42,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::istream_iterator<int> T;
@@ -61,4 +61,6 @@
     test_trivial<S>()();
     test_trivial<std::string>()();
 #endif
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/istream.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf(" 1 23");
     std::istream_iterator<int> i(inf);
@@ -26,4 +26,6 @@
     int j = 0;
     inf >> j;
     assert(j == 23);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/arrow.pass.cpp
@@ -29,10 +29,12 @@
     return is >> a.d_ >> a.i_;
 }
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf("1.5  23 ");
     std::istream_iterator<A> i(inf);
     assert(i->d_ == 1.5);
     assert(i->i_ == 23);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/dereference.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf(" 1 23");
     std::istream_iterator<int> i(inf);
@@ -30,4 +30,6 @@
     assert(j == 23);
     j = *i;
     assert(j == 23);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
@@ -22,7 +22,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf1(" 1 23");
     std::istringstream inf2(" 1 23");
@@ -51,4 +51,6 @@
 
     assert(std::operator==(i1, i2));
     assert(std::operator!=(i1, i3));
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/post_increment.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf(" 1 23");
     std::istream_iterator<int> i(inf);
@@ -28,4 +28,6 @@
     j = 0;
     j = *icopy;
     assert(j == 1);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/pre_increment.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream inf(" 1 23");
     std::istream_iterator<int> i(inf);
@@ -25,4 +25,6 @@
     int j = 0;
     j = *i;
     assert(j == 23);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
+++ test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp
@@ -41,7 +41,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::istream_iterator<double> I1; // double is trivially destructible
 #if TEST_STD_VER <= 14
@@ -82,4 +82,6 @@
     typedef std::istream_iterator<std::string> I3; // string is NOT trivially destructible
     static_assert(!std::is_trivially_copy_constructible<I3>::value, "");
     static_assert(!std::is_trivially_destructible<I3>::value, "");
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::istreambuf_iterator<char> T;
@@ -41,4 +41,6 @@
         (void)it2;
 #endif
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/istream.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf;
@@ -38,4 +38,6 @@
         std::istreambuf_iterator<wchar_t> i(inf);
         assert(i != std::istreambuf_iterator<wchar_t>());
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/proxy.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -32,4 +32,6 @@
         assert(i != std::istreambuf_iterator<wchar_t>());
         assert(*i == L'b');
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/streambuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istreambuf_iterator<char> i(nullptr);
@@ -46,4 +46,6 @@
         std::istreambuf_iterator<wchar_t> i(inf.rdbuf());
         assert(i != std::istreambuf_iterator<wchar_t>());
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_equal/equal.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf1("abc");
@@ -96,4 +96,6 @@
         assert( i5.equal(i4));
         assert( i5.equal(i5));
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf1("abc");
@@ -98,4 +98,6 @@
         assert(!(i5 != i4));
         assert(!(i5 != i5));
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op++/dereference.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -36,4 +36,6 @@
         ++i;
         assert(*i == L'c');
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.pass.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf1("abc");
@@ -98,4 +98,6 @@
         assert( (i5 == i4));
         assert( (i5 == i5));
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/post_increment.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -34,4 +34,6 @@
         assert(*i++ == L'c');
         assert(i == std::istreambuf_iterator<wchar_t>());
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op_astrk/pre_increment.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -35,4 +35,6 @@
         assert(*++i == L'c');
         assert(++i == std::istreambuf_iterator<wchar_t>());
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp
@@ -28,7 +28,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream inf("abc");
@@ -40,4 +40,6 @@
         std::istreambuf_iterator<wchar_t> i(inf);
         assert(*i++ == L'a');
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
+++ test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp
@@ -34,7 +34,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::istreambuf_iterator<char> I1;
     static_assert((std::is_same<I1::iterator_category, std::input_iterator_tag>::value), "");
@@ -65,4 +65,6 @@
     static_assert((std::is_nothrow_default_constructible<I2>::value), "" );
     static_assert((std::is_trivially_copy_constructible<I2>::value), "" );
     static_assert((std::is_trivially_destructible<I2>::value), "" );
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp
+++ test/std/iterators/stream.iterators/iterator.range/begin_array.pass.cpp
@@ -13,11 +13,13 @@
 #include <iterator>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     int* i = std::begin(ia);
     assert(*i == 1);
     *i = 2;
     assert(ia[0] == 2);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp
+++ test/std/iterators/stream.iterators/iterator.range/begin_const.pass.cpp
@@ -13,10 +13,12 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     const std::vector<int> v(ia, ia + sizeof(ia)/sizeof(ia[0]));
     std::vector<int>::const_iterator i = begin(v);
     assert(*i == 1);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp
+++ test/std/iterators/stream.iterators/iterator.range/begin_non_const.pass.cpp
@@ -13,7 +13,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     std::vector<int> v(ia, ia + sizeof(ia)/sizeof(ia[0]));
@@ -21,4 +21,6 @@
     assert(*i == 1);
     *i = 2;
     assert(*i == 2);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp
+++ test/std/iterators/stream.iterators/iterator.range/end_array.pass.cpp
@@ -13,11 +13,13 @@
 #include <iterator>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     int* i = std::begin(ia);
     int* e = std::end(ia);
     assert(e == ia + 3);
     assert(e - i == 3);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp
+++ test/std/iterators/stream.iterators/iterator.range/end_const.pass.cpp
@@ -13,10 +13,12 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     const std::vector<int> v(ia, ia + sizeof(ia)/sizeof(ia[0]));
     std::vector<int>::const_iterator i = end(v);
     assert(i == v.cend());
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp
+++ test/std/iterators/stream.iterators/iterator.range/end_non_const.pass.cpp
@@ -13,10 +13,12 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int ia[] = {1, 2, 3};
     std::vector<int> v(ia, ia + sizeof(ia)/sizeof(ia[0]));
     std::vector<int>::iterator i = end(v);
     assert(i == v.end());
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/nothing_to_do.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/nothing_to_do.pass.cpp
+++ test/std/iterators/stream.iterators/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp
+++ test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/copy.pass.cpp
@@ -16,11 +16,13 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream outf;
     std::ostream_iterator<int> i(outf);
     std::ostream_iterator<int> j = i;
     assert(outf.good());
     ((void)j);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
+++ test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream.pass.cpp
@@ -23,7 +23,7 @@
 
 void operator&(BasicStream const&) {}
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -35,4 +35,6 @@
         std::ostream_iterator<int, char, MyTraits> i(outf);
         assert(outf.good());
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
+++ test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/ostream_delim.pass.cpp
@@ -24,7 +24,7 @@
 
 void operator&(BasicStream const&) {}
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -41,4 +41,6 @@
         std::ostream_iterator<int, char, MyTraits> i(outf, ", ");
         assert(outf.good());
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp
+++ test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/assign_t.pass.cpp
@@ -26,7 +26,7 @@
 #pragma warning(disable: 4244) // conversion from 'X' to 'Y', possible loss of data
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -52,4 +52,6 @@
         i = 2.4;
         assert(outf.str() == L"2, ");
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp
+++ test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/dereference.pass.cpp
@@ -16,10 +16,12 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream os;
     std::ostream_iterator<int> i(os);
     std::ostream_iterator<int>& iref = *i;
     assert(&iref == &i);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp
+++ test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.ops/increment.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream os;
     std::ostream_iterator<int> i(os);
@@ -25,4 +25,6 @@
     assert(&iref1 == &i);
     std::ostream_iterator<int>& iref2 = i++;
     assert(&iref2 == &i);
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp
+++ test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::ostream_iterator<double> I1;
 #if TEST_STD_VER <= 14
@@ -54,4 +54,6 @@
     static_assert((std::is_same<I2::char_type, wchar_t>::value), "");
     static_assert((std::is_same<I2::traits_type, std::char_traits<wchar_t> >::value), "");
     static_assert((std::is_same<I2::ostream_type, std::wostream>::value), "");
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp
+++ test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/ostream.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -28,4 +28,6 @@
         std::ostreambuf_iterator<wchar_t> i(outf);
         assert(!i.failed());
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp
+++ test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/streambuf.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -28,4 +28,6 @@
         std::ostreambuf_iterator<wchar_t> i(outf.rdbuf());
         assert(!i.failed());
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp
+++ test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/assign_c.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -35,4 +35,6 @@
         i = L'b';
         assert(outf.str() == L"ab");
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp
+++ test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/deref.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -30,4 +30,6 @@
         std::ostreambuf_iterator<wchar_t>& iref = *i;
         assert(&iref == &i);
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp
+++ test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/failed.pass.cpp
@@ -25,7 +25,7 @@
     int_type sputc(char_type) { return Traits::eof(); }
     };
 
-int main()
+int main(int, char**)
 {
     {
         my_streambuf<char> buf;
@@ -39,4 +39,6 @@
         i = L'a';
         assert(i.failed());
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp
+++ test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.ops/increment.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream outf;
@@ -35,4 +35,6 @@
         std::ostreambuf_iterator<wchar_t>& iref2 = i++;
         assert(&iref2 == &i);
     }
+
+  return 0;
 }
Index: test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp
===================================================================
--- test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp
+++ test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::ostreambuf_iterator<char> I1;
 #if TEST_STD_VER <= 14
@@ -58,4 +58,6 @@
     static_assert((std::is_same<I2::traits_type, std::char_traits<wchar_t> >::value), "");
     static_assert((std::is_same<I2::streambuf_type, std::wstreambuf>::value), "");
     static_assert((std::is_same<I2::ostream_type, std::wostream>::value), "");
+
+  return 0;
 }
Index: test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
===================================================================
--- test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
+++ test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
@@ -33,7 +33,7 @@
 
 // [class.spaceship]p4: The 'common comparison type' U of a possibly-empty list
 //   of 'n' types T0, T1, ..., TN, is defined as follows:
-int main() {
+int main(int, char**) {
   using WE = std::weak_equality;
   using SE = std::strong_equality;
   using PO = std::partial_ordering;
@@ -89,4 +89,6 @@
     test_cat<SO, SO>();
     test_cat<SO, SO, SO>();
   }
+
+  return 0;
 }
Index: test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
===================================================================
--- test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
+++ test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
@@ -155,9 +155,11 @@
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   static_assert(test_conversion(), "conversion test failed");
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
Index: test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
===================================================================
--- test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
+++ test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
@@ -87,9 +87,11 @@
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   test_conversion();
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
Index: test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
===================================================================
--- test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
+++ test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
@@ -203,9 +203,11 @@
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   static_assert(test_conversion(), "conversion test failed");
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
Index: test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
===================================================================
--- test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
+++ test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
@@ -62,8 +62,10 @@
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
Index: test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
===================================================================
--- test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
+++ test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
@@ -160,9 +160,11 @@
   return true;
 }
 
-int main() {
+int main(int, char**) {
   test_static_members();
   test_signatures();
   static_assert(test_conversion(), "conversion test failed");
   static_assert(test_constexpr(), "constexpr test failed");
+
+  return 0;
 }
Index: test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
===================================================================
--- test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
+++ test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp
@@ -18,7 +18,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     // typedef std::int8_t
     static_assert(sizeof(std::int8_t)*CHAR_BIT == 8,
@@ -288,4 +288,6 @@
 #ifndef UINTMAX_C
 #error UINTMAX_C not defined
 #endif
+
+  return 0;
 }
Index: test/std/language.support/nothing_to_do.pass.cpp
===================================================================
--- test/std/language.support/nothing_to_do.pass.cpp
+++ test/std/language.support/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/align_val_t.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/align_val_t.pass.cpp
+++ test/std/language.support/support.dynamic/align_val_t.pass.cpp
@@ -14,7 +14,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   {
     static_assert(std::is_enum<std::align_val_t>::value, "");
     static_assert(std::is_same<std::underlying_type<std::align_val_t>::type, std::size_t>::value, "");
@@ -30,4 +30,6 @@
     static_assert(b == std::align_val_t(32), "");
     static_assert(static_cast<std::size_t>(c) == (std::size_t)-1, "");
   }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp
+++ test/std/language.support/support.dynamic/alloc.errors/bad.alloc/bad_alloc.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_alloc>::value),
                  "std::is_base_of<std::exception, std::bad_alloc>::value");
@@ -23,4 +23,6 @@
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp
+++ test/std/language.support/support.dynamic/alloc.errors/new.handler/new_handler.pass.cpp
@@ -14,9 +14,11 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::new_handler, void(*)()>::value), "");
     std::new_handler p = f;
     assert(p == &f);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp
+++ test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_new_length.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::bad_alloc, std::bad_array_new_length>::value),
                   "std::is_base_of<std::bad_alloc, std::bad_array_new_length>::value");
@@ -23,4 +23,6 @@
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp
+++ test/std/language.support/support.dynamic/alloc.errors/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp
+++ test/std/language.support/support.dynamic/alloc.errors/set.new.handler/get_new_handler.pass.cpp
@@ -14,11 +14,13 @@
 void f1() {}
 void f2() {}
 
-int main()
+int main(int, char**)
 {
     assert(std::get_new_handler() == 0);
     std::set_new_handler(f1);
     assert(std::get_new_handler() == f1);
     std::set_new_handler(f2);
     assert(std::get_new_handler() == f2);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp
+++ test/std/language.support/support.dynamic/alloc.errors/set.new.handler/set_new_handler.pass.cpp
@@ -14,8 +14,10 @@
 void f1() {}
 void f2() {}
 
-int main()
+int main(int, char**)
 {
     assert(std::set_new_handler(f1) == 0);
     assert(std::set_new_handler(f2) == f1);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
@@ -83,7 +83,7 @@
 struct alignas(OverAligned) A {};
 struct alignas(std::max_align_t) B {};
 
-int main()
+int main(int, char**)
 {
     reset();
     {
@@ -113,4 +113,6 @@
         assert(0 == unsized_delete_nothrow_called);
         assert(1 == aligned_delete_called);
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
@@ -90,7 +90,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new A[2];
@@ -103,4 +103,6 @@
     {
         test_throw_max_size();
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
@@ -92,7 +92,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new(std::nothrow) A[3];
@@ -105,4 +105,6 @@
     {
         test_max_alloc();
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
@@ -86,7 +86,7 @@
     --new_called;
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new (std::nothrow) A[2];
@@ -106,4 +106,6 @@
         assert(!new_called);
         assert(!B_constructed);
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
@@ -66,7 +66,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new A[3];
@@ -85,4 +85,6 @@
         delete [] bp;
         assert(!new_called);
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array.pass.cpp
@@ -34,7 +34,7 @@
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     std::set_new_handler(my_new_handler);
@@ -60,4 +60,6 @@
     delete [] ap;
     DoNotOptimize(ap);
     assert(A_constructed == 0);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow.pass.cpp
@@ -34,7 +34,7 @@
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     std::set_new_handler(my_new_handler);
 #ifndef TEST_HAS_NO_EXCEPTIONS
@@ -59,4 +59,6 @@
     delete [] ap;
     DoNotOptimize(ap);
     assert(A_constructed == 0);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
@@ -43,7 +43,7 @@
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     A *ap = new (std::nothrow) A[3];
     DoNotOptimize(ap);
@@ -54,4 +54,6 @@
     DoNotOptimize(ap);
     assert(A_constructed == 0);
     assert(!new_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
@@ -44,7 +44,7 @@
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     A *ap = new A[3];
     DoNotOptimize(ap);
@@ -55,4 +55,6 @@
     DoNotOptimize(ap);
     assert(A_constructed == 0);
     assert(new_called == 0);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new[](4);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new[](4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new[](4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new[](4, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
@@ -54,7 +54,7 @@
 //   selected.
 struct A { ~A() {} };
 
-int main()
+int main(int, char**)
 {
 
     A* x = new A[3];
@@ -66,4 +66,6 @@
     assert(1 == unsized_delete_called);
     assert(0 == sized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
@@ -59,7 +59,7 @@
 //   selected.
 struct A { ~A() {} };
 
-int main()
+int main(int, char**)
 {
     A* x = new A[3];
     assert(0 == unsized_delete_called);
@@ -70,4 +70,6 @@
     assert(0 == unsized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
     assert(1 == sized_delete_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_calls_unsized_delete_array.pass.cpp
@@ -45,7 +45,7 @@
 //   selected.
 struct A { ~A() {} };
 
-int main()
+int main(int, char**)
 {
     A *x = new A[3];
     DoNotOptimize(x);
@@ -56,4 +56,6 @@
     DoNotOptimize(x);
     assert(1 == delete_called);
     assert(0 == delete_nothrow_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array_fsizeddeallocation.sh.cpp
@@ -73,7 +73,7 @@
 //   selected.
 struct A { ~A() {} };
 
-int main()
+int main(int, char**)
 {
     A* x = new A[3];
     assert(0 == unsized_delete_called);
@@ -84,4 +84,6 @@
     assert(0 == unsized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
     assert(1 == sized_delete_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.dataraces/not_testable.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.placement/new.pass.cpp
@@ -19,11 +19,13 @@
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     char buf[sizeof(A)];
 
     A* ap = new(buf) A;
     assert((char*)ap == buf);
     assert(A_constructed == 1);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array.pass.cpp
@@ -19,7 +19,7 @@
     ~A() {--A_constructed;}
 };
 
-int main()
+int main(int, char**)
 {
     const std::size_t Size = 3;
     // placement new might require additional space.
@@ -30,4 +30,6 @@
     assert((char*)ap >= buf);
     assert((char*)ap < (buf + ExtraSize));
     assert(A_constructed == Size);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
@@ -18,8 +18,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     char buffer[100];
     ::operator new[](4, buffer);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
@@ -18,8 +18,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     char buffer[100];
     ::operator new(4, buffer);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
@@ -82,7 +82,7 @@
 struct alignas(OverAligned) A {};
 struct alignas(std::max_align_t) B {};
 
-int main()
+int main(int, char**)
 {
     reset();
     {
@@ -112,4 +112,6 @@
         assert(0 == unsized_delete_nothrow_called);
         assert(1 == aligned_delete_called);
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new.pass.cpp
@@ -34,7 +34,7 @@
     ~A() {A_constructed = false;}
 };
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     std::set_new_handler(my_new_handler);
@@ -58,4 +58,6 @@
     assert(A_constructed);
     delete ap;
     assert(!A_constructed);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
@@ -90,7 +90,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new A;
@@ -103,4 +103,6 @@
     {
         test_throw_max_size();
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
@@ -92,7 +92,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new(std::nothrow) A;
@@ -105,4 +105,6 @@
     {
         test_max_alloc();
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
@@ -88,7 +88,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new (std::nothrow) A;
@@ -108,4 +108,6 @@
         assert(!new_called);
         assert(!B_constructed);
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
@@ -66,7 +66,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         A* ap = new A;
@@ -85,4 +85,6 @@
         delete bp;
         assert(!new_called);
     }
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow.pass.cpp
@@ -34,7 +34,7 @@
     ~A() {A_constructed = false;}
 };
 
-int main()
+int main(int, char**)
 {
     std::set_new_handler(my_new_handler);
 #ifndef TEST_HAS_NO_EXCEPTIONS
@@ -56,4 +56,6 @@
     assert(A_constructed);
     delete ap;
     assert(!A_constructed);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
@@ -43,7 +43,7 @@
     ~A() {A_constructed = false;}
 };
 
-int main()
+int main(int, char**)
 {
     A *ap = new (std::nothrow) A;
     DoNotOptimize(ap);
@@ -54,4 +54,6 @@
     DoNotOptimize(ap);
     assert(!A_constructed);
     assert(!new_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp
@@ -42,7 +42,7 @@
     ~A() {A_constructed = false;}
 };
 
-int main()
+int main(int, char**)
 {
     A *ap = new A;
     DoNotOptimize(ap);
@@ -53,4 +53,6 @@
     DoNotOptimize(ap);
     assert(!A_constructed);
     assert(!new_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
@@ -18,7 +18,9 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     ::operator new(4);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new(4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.sh.cpp
@@ -19,7 +19,9 @@
 
 #include <new>
 
-int main ()
+int main(int, char**)
 {
     ::operator new(4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
@@ -18,7 +18,9 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     ::operator new(4, std::nothrow);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
@@ -43,7 +43,7 @@
     std::free(p);
 }
 
-int main()
+int main(int, char**)
 {
     int *x = new int(42);
     DoNotOptimize(x);
@@ -56,4 +56,6 @@
     assert(1 == unsized_delete_called);
     assert(0 == sized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
@@ -48,7 +48,7 @@
     std::free(p);
 }
 
-int main()
+int main(int, char**)
 {
     int *x = new int(42);
     DoNotOptimize(x);
@@ -61,4 +61,6 @@
     assert(0 == unsized_delete_called);
     assert(1 == sized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_calls_unsized_delete.pass.cpp
@@ -34,7 +34,7 @@
     std::free(p);
 }
 
-int main()
+int main(int, char**)
 {
     int *x = new int(42);
     DoNotOptimize(x);
@@ -45,4 +45,6 @@
     DoNotOptimize(x);
     assert(1 == delete_called);
     assert(0 == delete_nothrow_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
+++ test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete_fsizeddeallocation.sh.cpp
@@ -61,7 +61,7 @@
     std::free(p);
 }
 
-int main()
+int main(int, char**)
 {
     int *x = new int(42);
     DoNotOptimize(x);
@@ -74,4 +74,6 @@
     assert(1 == sized_delete_called);
     assert(0 == unsized_delete_called);
     assert(0 == unsized_delete_nothrow_called);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp
+++ test/std/language.support/support.dynamic/new.delete/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
===================================================================
--- test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
+++ test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
@@ -19,8 +19,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     int *p = nullptr;
     std::launder(p);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
===================================================================
--- test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
+++ test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
@@ -20,7 +20,7 @@
 constexpr int gi = 5;
 constexpr float gf = 8.f;
 
-int main() {
+int main(int, char**) {
     static_assert(std::launder(&gi) == &gi, "" );
     static_assert(std::launder(&gf) == &gf, "" );
 
@@ -31,4 +31,6 @@
 
     assert(std::launder(i) == i);
     assert(std::launder(f) == f);
+
+  return 0;
 }
Index: test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
===================================================================
--- test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
+++ test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
@@ -21,7 +21,7 @@
 
 void foo() {}
 
-int main ()
+int main(int, char**)
 {
     void *p = nullptr;
     (void) std::launder((               void *) nullptr);
@@ -32,4 +32,6 @@
 
     (void) std::launder(foo);                              // expected-error-re@new:* 1 {{static_assert failed{{.*}} "can't launder functions"}}
     // expected-error@new:* 0-1 {{function pointer argument to '__builtin_launder' is not allowed}}
+
+  return 0;
 }
Index: test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp
===================================================================
--- test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp
+++ test/std/language.support/support.exception/bad.exception/bad_exception.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_exception>::value),
                  "std::is_base_of<std::exception, std::bad_exception>::value");
@@ -23,4 +23,6 @@
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/except.nested/assign.pass.cpp
===================================================================
--- test/std/language.support/support.exception/except.nested/assign.pass.cpp
+++ test/std/language.support/support.exception/except.nested/assign.pass.cpp
@@ -26,7 +26,7 @@
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::nested_exception e0;
@@ -59,4 +59,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp
===================================================================
--- test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp
+++ test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp
@@ -26,7 +26,7 @@
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::nested_exception e0;
@@ -57,4 +57,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp
===================================================================
--- test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp
+++ test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp
@@ -26,7 +26,7 @@
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::nested_exception e;
@@ -55,4 +55,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
===================================================================
--- test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
+++ test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
@@ -56,7 +56,7 @@
 class E2 : public std::nested_exception {};
 class E : public E1, public E2 {};
 
-int main()
+int main(int, char**)
 {
     {
         try
@@ -131,4 +131,6 @@
         }
     }
 
+
+  return 0;
 }
Index: test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp
===================================================================
--- test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp
+++ test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp
@@ -31,7 +31,7 @@
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     {
         try
@@ -67,4 +67,6 @@
             assert(false);
         }
     }
+
+  return 0;
 }
Index: test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
===================================================================
--- test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
+++ test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp
@@ -42,7 +42,7 @@
 struct Final final {};
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         try
@@ -128,4 +128,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp
===================================================================
--- test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp
+++ test/std/language.support/support.exception/exception.terminate/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp
===================================================================
--- test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp
+++ test/std/language.support/support.exception/exception.terminate/set.terminate/get_terminate.pass.cpp
@@ -15,10 +15,12 @@
 void f1() {}
 void f2() {}
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     assert(std::get_terminate() == f1);
     std::set_terminate(f2);
     assert(std::get_terminate() == f2);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp
===================================================================
--- test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp
+++ test/std/language.support/support.exception/exception.terminate/set.terminate/set_terminate.pass.cpp
@@ -15,8 +15,10 @@
 void f1() {}
 void f2() {}
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     assert(std::set_terminate(f2) == f1);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp
===================================================================
--- test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp
+++ test/std/language.support/support.exception/exception.terminate/terminate.handler/terminate_handler.pass.cpp
@@ -14,9 +14,11 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::terminate_handler, void(*)()>::value), "");
     std::terminate_handler p = f;
     assert(p == &f);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp
===================================================================
--- test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp
+++ test/std/language.support/support.exception/exception.terminate/terminate/terminate.pass.cpp
@@ -17,9 +17,11 @@
     std::exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     std::terminate();
     assert(false);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/exception/exception.pass.cpp
===================================================================
--- test/std/language.support/support.exception/exception/exception.pass.cpp
+++ test/std/language.support/support.exception/exception/exception.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_polymorphic<std::exception>::value,
                  "std::is_polymorphic<std::exception>::value");
@@ -21,4 +21,6 @@
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/propagation/current_exception.pass.cpp
===================================================================
--- test/std/language.support/support.exception/propagation/current_exception.pass.cpp
+++ test/std/language.support/support.exception/propagation/current_exception.pass.cpp
@@ -29,7 +29,7 @@
 
 int A::constructed = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::exception_ptr p = std::current_exception();
@@ -270,4 +270,6 @@
         assert(p != nullptr);
     }
     assert(A::constructed == 0);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp
===================================================================
--- test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp
+++ test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp
@@ -15,7 +15,7 @@
 #include <exception>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::exception_ptr p;
     assert(p == nullptr);
@@ -30,4 +30,6 @@
     assert(p3 == nullptr);
     p3 = nullptr;
     assert(p3 == nullptr);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp
===================================================================
--- test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp
+++ test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp
@@ -26,7 +26,7 @@
 
 int A::constructed = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::exception_ptr p = std::make_exception_ptr(A(5));
@@ -52,4 +52,6 @@
         assert(A::constructed == 0);
     }
     assert(A::constructed == 0);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp
===================================================================
--- test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp
+++ test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp
@@ -26,7 +26,7 @@
 
 int A::constructed = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::exception_ptr p;
@@ -60,4 +60,6 @@
         assert(A::constructed == 0);
     }
     assert(A::constructed == 0);
+
+  return 0;
 }
Index: test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp
===================================================================
--- test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp
+++ test/std/language.support/support.exception/uncaught/uncaught_exception.pass.cpp
@@ -29,7 +29,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     try
     {
@@ -42,4 +42,6 @@
         assert(!std::uncaught_exception());
     }
     assert(!std::uncaught_exception());
+
+  return 0;
 }
Index: test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp
===================================================================
--- test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp
+++ test/std/language.support/support.exception/uncaught/uncaught_exceptions.pass.cpp
@@ -41,7 +41,7 @@
     int d_;
 };
 
-int main () {
+int main(int, char**) {
     assert(std::uncaught_exceptions() == 0);
     {
     Outer o(0);
@@ -58,4 +58,6 @@
         }
     }
     assert(std::uncaught_exceptions() == 0);
+
+  return 0;
 }
Index: test/std/language.support/support.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/language.support/support.general/nothing_to_do.pass.cpp
+++ test/std/language.support/support.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.initlist/include_cxx03.pass.cpp
===================================================================
--- test/std/language.support/support.initlist/include_cxx03.pass.cpp
+++ test/std/language.support/support.initlist/include_cxx03.pass.cpp
@@ -12,6 +12,8 @@
 
 #include <initializer_list>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
===================================================================
--- test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
+++ test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
@@ -51,11 +51,13 @@
 
 #endif  // TEST_STD_VER > 11
 
-int main()
+int main(int, char**)
 {
     A test1 = {3, 2, 1};
 #if TEST_STD_VER > 11
     constexpr B test2 = {3, 2, 1};
     (void)test2;
 #endif  // TEST_STD_VER > 11
+
+  return 0;
 }
Index: test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp
===================================================================
--- test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp
+++ test/std/language.support/support.initlist/support.initlist.cons/default.pass.cpp
@@ -19,7 +19,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     std::initializer_list<A> il;
     assert(il.size() == 0);
@@ -28,4 +28,6 @@
     constexpr std::initializer_list<A> il2;
     static_assert(il2.size() == 0, "");
 #endif  // TEST_STD_VER > 11
+
+  return 0;
 }
Index: test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
===================================================================
--- test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
+++ test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
@@ -49,11 +49,13 @@
 
 #endif  // TEST_STD_VER > 11
 
-int main()
+int main(int, char**)
 {
     A test1 = {3, 2, 1};
 #if TEST_STD_VER > 11
     constexpr B test2 = {3, 2, 1};
     (void)test2;
 #endif  // TEST_STD_VER > 11
+
+  return 0;
 }
Index: test/std/language.support/support.initlist/types.pass.cpp
===================================================================
--- test/std/language.support/support.initlist/types.pass.cpp
+++ test/std/language.support/support.initlist/types.pass.cpp
@@ -25,7 +25,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::initializer_list<A>::value_type, A>::value), "");
     static_assert((std::is_same<std::initializer_list<A>::reference, const A&>::value), "");
@@ -33,4 +33,6 @@
     static_assert((std::is_same<std::initializer_list<A>::size_type, std::size_t>::value), "");
     static_assert((std::is_same<std::initializer_list<A>::iterator, const A*>::value), "");
     static_assert((std::is_same<std::initializer_list<A>::const_iterator, const A*>::value), "");
+
+  return 0;
 }
Index: test/std/language.support/support.limits/c.limits/cfloat.pass.cpp
===================================================================
--- test/std/language.support/support.limits/c.limits/cfloat.pass.cpp
+++ test/std/language.support/support.limits/c.limits/cfloat.pass.cpp
@@ -178,6 +178,8 @@
 #endif
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.limits/c.limits/climits.pass.cpp
===================================================================
--- test/std/language.support/support.limits/c.limits/climits.pass.cpp
+++ test/std/language.support/support.limits/c.limits/climits.pass.cpp
@@ -86,6 +86,8 @@
 #error ULLONG_MAX not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp
+++ test/std/language.support/support.limits/limits/denorm.style/check_values.pass.cpp
@@ -18,7 +18,7 @@
 one test(std::float_round_style);
 two test(int);
 
-int main()
+int main(int, char**)
 {
     static_assert(std::round_indeterminate == -1,
                  "std::round_indeterminate == -1");
@@ -34,4 +34,6 @@
                  "sizeof(test(std::round_to_nearest)) == 1");
     static_assert(sizeof(test(1)) == 2,
                  "sizeof(test(1)) == 2");
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/is_specialized.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/is_specialized.pass.cpp
+++ test/std/language.support/support.limits/limits/is_specialized.pass.cpp
@@ -39,7 +39,7 @@
                  "std::numeric_limits<const volatile T>::is_specialized");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>();
     test<char>();
@@ -67,4 +67,6 @@
     test<long double>();
     static_assert(!std::numeric_limits<std::complex<double> >::is_specialized,
                  "!std::numeric_limits<std::complex<double> >::is_specialized");
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
@@ -68,7 +68,7 @@
 
 struct other {};
 
-int main()
+int main(int, char**)
 {
     // bool
     TEST_NUMERIC_LIMITS(bool)
@@ -205,4 +205,6 @@
     TEST_NUMERIC_LIMITS(const other)
     TEST_NUMERIC_LIMITS(volatile other)
     TEST_NUMERIC_LIMITS(const volatile other)
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp
@@ -26,7 +26,7 @@
     assert(std::numeric_limits<const volatile T>::denorm_min() == expected);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
@@ -65,4 +65,6 @@
 #if !defined(__FLT_DENORM_MIN__) && !defined(FLT_TRUE_MIN)
 #error Test has no expected values for floating point types
 #endif
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp
@@ -25,7 +25,7 @@
     static_assert(std::numeric_limits<const volatile T>::digits == expected, "digits test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 1>();
     test<char, std::numeric_limits<char>::is_signed ? 7 : 8>();
@@ -54,4 +54,6 @@
     test<float, FLT_MANT_DIG>();
     test<double, DBL_MANT_DIG>();
     test<long double, LDBL_MANT_DIG>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp
@@ -29,7 +29,7 @@
     static_assert(std::numeric_limits<const volatile T>::is_bounded, "digits10 test 8");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 2>();
@@ -58,4 +58,6 @@
     test<float, FLT_DIG>();
     test<double, DBL_DIG>();
     test<long double, LDBL_DIG>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp
@@ -26,7 +26,7 @@
     assert(std::numeric_limits<const volatile T>::epsilon() == expected);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
@@ -55,4 +55,6 @@
     test<float>(FLT_EPSILON);
     test<double>(DBL_EPSILON);
     test<long double>(LDBL_EPSILON);
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::has_denorm == expected, "has_denorm test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, std::denorm_absent>();
     test<char, std::denorm_absent>();
@@ -53,4 +53,6 @@
     test<float, std::denorm_present>();
     test<double, std::denorm_present>();
     test<long double, std::denorm_present>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::has_denorm_loss == expected, "has_denorm_loss test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::has_infinity == expected, "has_infinity test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::has_quiet_NaN == expected, "has_quiet_NaN test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::has_signaling_NaN == expected, "has_signaling_NaN test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp
@@ -28,7 +28,7 @@
 
 extern float zero;
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
@@ -57,6 +57,8 @@
     test<float>(1.f/zero);
     test<double>(1./zero);
     test<long double>(1./zero);
+
+  return 0;
 }
 
 float zero = 0;
Index: test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::is_bounded == expected, "is_bounded test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, true>();
     test<char, true>();
@@ -53,4 +53,6 @@
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::is_exact == expected, "is_exact test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, true>();
     test<char, true>();
@@ -53,4 +53,6 @@
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::is_iec559 == expected, "is_iec559 test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -57,4 +57,6 @@
 #else
     test<long double, true>();
 #endif
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::is_integer == expected, "is_integer test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, true>();
     test<char, true>();
@@ -53,4 +53,6 @@
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::is_modulo == expected, "is_modulo test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
 //    test<char, false>(); // don't know
@@ -53,4 +53,6 @@
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::is_signed == expected, "is_signed test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, char(-1) < char(0)>();
@@ -53,4 +53,6 @@
     test<float, true>();
     test<double, true>();
     test<long double, true>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp
@@ -32,7 +32,7 @@
     assert(std::numeric_limits<const volatile T>::is_bounded);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(CHAR_MIN);
@@ -61,4 +61,6 @@
     test<float>(-FLT_MAX);
     test<double>(-DBL_MAX);
     test<long double>(-LDBL_MAX);
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp
@@ -32,7 +32,7 @@
     assert(std::numeric_limits<const volatile T>::is_bounded);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(true);
     test<char>(CHAR_MAX);
@@ -61,4 +61,6 @@
     test<float>(FLT_MAX);
     test<double>(DBL_MAX);
     test<long double>(LDBL_MAX);
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp
@@ -25,7 +25,7 @@
     static_assert(std::numeric_limits<const volatile T>::max_digits10 == expected, "max_digits10 test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@
     test<float, 2+(FLT_MANT_DIG * 30103)/100000>();
     test<double, 2+(DBL_MANT_DIG * 30103)/100000>();
     test<long double, 2+(LDBL_MANT_DIG * 30103)/100000>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp
@@ -25,7 +25,7 @@
     static_assert(std::numeric_limits<const volatile T>::max_exponent == expected, "max_exponent test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@
     test<float, FLT_MAX_EXP>();
     test<double, DBL_MAX_EXP>();
     test<long double, LDBL_MAX_EXP>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp
@@ -25,7 +25,7 @@
     static_assert(std::numeric_limits<const volatile T>::max_exponent10 == expected, "max_exponent10 test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@
     test<float, FLT_MAX_10_EXP>();
     test<double, DBL_MAX_10_EXP>();
     test<long double, LDBL_MAX_10_EXP>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp
@@ -32,7 +32,7 @@
     assert(std::numeric_limits<const volatile T>::is_bounded || !std::numeric_limits<const volatile T>::is_signed);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(CHAR_MIN);
@@ -61,4 +61,6 @@
     test<float>(FLT_MIN);
     test<double>(DBL_MIN);
     test<long double>(LDBL_MIN);
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp
@@ -25,7 +25,7 @@
     static_assert(std::numeric_limits<const volatile T>::min_exponent == expected, "min_exponent test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@
     test<float, FLT_MIN_EXP>();
     test<double, DBL_MIN_EXP>();
     test<long double, LDBL_MIN_EXP>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp
@@ -25,7 +25,7 @@
     static_assert(std::numeric_limits<const volatile T>::min_exponent10 == expected, "min_exponent10 test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
@@ -54,4 +54,6 @@
     test<float, FLT_MIN_10_EXP>();
     test<double, DBL_MIN_10_EXP>();
     test<long double, LDBL_MIN_10_EXP>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp
@@ -45,7 +45,7 @@
     test_imp<T>(std::is_floating_point<T>());
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>();
     test<char>();
@@ -74,4 +74,6 @@
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp
@@ -25,7 +25,7 @@
     static_assert(std::numeric_limits<const volatile T>::radix == expected, "radix test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, 2>();
     test<char, 2>();
@@ -54,4 +54,6 @@
     test<float, FLT_RADIX>();
     test<double, FLT_RADIX>();
     test<long double, FLT_RADIX>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp
@@ -26,7 +26,7 @@
     assert(std::numeric_limits<const volatile T>::round_error() == expected);
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
@@ -55,4 +55,6 @@
     test<float>(0.5);
     test<double>(0.5);
     test<long double>(0.5);
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::round_style == expected, "round_style test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, std::round_toward_zero>();
     test<char, std::round_toward_zero>();
@@ -53,4 +53,6 @@
     test<float, std::round_to_nearest>();
     test<double, std::round_to_nearest>();
     test<long double, std::round_to_nearest>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp
@@ -45,7 +45,7 @@
     test_imp<T>(std::is_floating_point<T>());
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>();
     test<char>();
@@ -74,4 +74,6 @@
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp
@@ -24,7 +24,7 @@
     static_assert(std::numeric_limits<const volatile T>::tinyness_before == expected, "tinyness_before test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
@@ -53,4 +53,6 @@
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp
@@ -31,7 +31,7 @@
     static_assert(std::numeric_limits<const volatile T>::traps == expected, "traps test 4");
 }
 
-int main()
+int main(int, char**)
 {
     test<bool, false>();
     test<char, integral_types_trap>();
@@ -60,4 +60,6 @@
     test<float, false>();
     test<double, false>();
     test<long double, false>();
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.limits/default.pass.cpp
@@ -22,7 +22,7 @@
 
 bool operator == (const A& x, const A& y) {return x.data_ == y.data_;}
 
-int main()
+int main(int, char**)
 {
     static_assert(std::numeric_limits<A>::is_specialized == false,
                  "std::numeric_limits<A>::is_specialized == false");
@@ -79,4 +79,6 @@
                  "std::numeric_limits<A>::tinyness_before == false");
     static_assert(std::numeric_limits<A>::round_style == std::round_toward_zero,
                  "std::numeric_limits<A>::round_style == std::round_toward_zero");
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp
+++ test/std/language.support/support.limits/limits/numeric.special/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp
===================================================================
--- test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp
+++ test/std/language.support/support.limits/limits/round.style/check_values.pass.cpp
@@ -18,7 +18,7 @@
 one test(std::float_denorm_style);
 two test(int);
 
-int main()
+int main(int, char**)
 {
     static_assert(std::denorm_indeterminate == -1,
                  "std::denorm_indeterminate == -1");
@@ -30,4 +30,6 @@
                  "sizeof(test(std::denorm_present)) == 1");
     static_assert(sizeof(test(1)) == 2,
                  "sizeof(test(1)) == 2");
+
+  return 0;
 }
Index: test/std/language.support/support.limits/nothing_to_do.pass.cpp
===================================================================
--- test/std/language.support/support.limits/nothing_to_do.pass.cpp
+++ test/std/language.support/support.limits/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/algorithm.version.pass.cpp
@@ -188,4 +188,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/any.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp
@@ -101,4 +101,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp
@@ -118,4 +118,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/charconv.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  ensure that the macros that are supposed to be defined in <utility> are defined.
 
@@ -28,4 +28,6 @@
 # error "__cpp_lib_fooby has an invalid value"
 #endif
 */
+
+  return 0;
 }
Index: test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/chrono.version.pass.cpp
@@ -78,4 +78,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/cmath.version.pass.cpp
@@ -87,4 +87,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/compare.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/concepts.version.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  ensure that the macros that are supposed to be defined in <concepts> are defined.
 
@@ -30,4 +30,6 @@
 # error "__cpp_lib_fooby has an invalid value"
 #endif
 */
+
+  return 0;
 }
Index: test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/cstddef.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp
@@ -95,4 +95,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/exception.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/execution.version.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  ensure that the macros that are supposed to be defined in <execution> are defined.
 
@@ -30,4 +30,6 @@
 # error "__cpp_lib_fooby has an invalid value"
 #endif
 */
+
+  return 0;
 }
Index: test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/filesystem.version.pass.cpp
@@ -78,4 +78,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp
@@ -144,4 +144,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp
@@ -241,4 +241,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/iomanip.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/istream.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp
@@ -179,4 +179,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/limits.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp
@@ -144,4 +144,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/locale.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp
@@ -167,4 +167,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp
@@ -243,4 +243,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 //  ensure that the macros that are supposed to be defined in <memory_resource> are defined.
 
@@ -30,4 +30,6 @@
 # error "__cpp_lib_fooby has an invalid value"
 #endif
 */
+
+  return 0;
 }
Index: test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/mutex.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/new.version.pass.cpp
@@ -101,4 +101,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/numeric.version.pass.cpp
@@ -87,4 +87,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/optional.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/ostream.version.pass.cpp
@@ -55,4 +55,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/regex.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/scoped_allocator.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp
@@ -144,4 +144,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/shared_mutex.version.pass.cpp
@@ -110,4 +110,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp
@@ -170,4 +170,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp
@@ -104,4 +104,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp
@@ -153,4 +153,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp
@@ -393,4 +393,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp
@@ -167,4 +167,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp
@@ -144,4 +144,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp
@@ -191,4 +191,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/variant.version.pass.cpp
@@ -52,4 +52,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp
@@ -118,4 +118,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
+++ test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
@@ -2174,4 +2174,4 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {}
+int main(int, char**) { return 0; }
Index: test/std/language.support/support.limits/version.pass.cpp
===================================================================
--- test/std/language.support/support.limits/version.pass.cpp
+++ test/std/language.support/support.limits/version.pass.cpp
@@ -11,6 +11,8 @@
 
 #include <version>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp
===================================================================
--- test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp
+++ test/std/language.support/support.rtti/bad.cast/bad_cast.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_cast>::value),
                  "std::is_base_of<std::exception, std::bad_cast>::value");
@@ -23,4 +23,6 @@
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
Index: test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp
===================================================================
--- test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp
+++ test/std/language.support/support.rtti/bad.typeid/bad_typeid.pass.cpp
@@ -12,7 +12,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_typeid>::value),
                  "std::is_base_of<std::exception, std::bad_typeid>::value");
@@ -23,4 +23,6 @@
     b2 = b;
     const char* w = b2.what();
     assert(w);
+
+  return 0;
 }
Index: test/std/language.support/support.rtti/type.info/type_info.pass.cpp
===================================================================
--- test/std/language.support/support.rtti/type.info/type_info.pass.cpp
+++ test/std/language.support/support.rtti/type.info/type_info.pass.cpp
@@ -16,7 +16,7 @@
 bool test_constructor_explicit(std::type_info const&) { return false; }
 bool test_constructor_explicit(std::string const&) { return true; }
 
-int main()
+int main(int, char**)
 {
   {
     const std::type_info& t1 = typeid(int);
@@ -36,4 +36,6 @@
     // See: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=216201
     assert(test_constructor_explicit("abc"));
   }
+
+  return 0;
 }
Index: test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp
===================================================================
--- test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp
+++ test/std/language.support/support.rtti/type.info/type_info_hash.pass.cpp
@@ -12,11 +12,13 @@
 #include <cstring>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::type_info& t1 = typeid(int);
     const std::type_info& t2 = typeid(int);
     const std::type_info& t3 = typeid(short);
     assert(t1.hash_code() == t2.hash_code());
     assert(t1.hash_code() != t3.hash_code());
+
+  return 0;
 }
Index: test/std/language.support/support.runtime/csetjmp.pass.cpp
===================================================================
--- test/std/language.support/support.runtime/csetjmp.pass.cpp
+++ test/std/language.support/support.runtime/csetjmp.pass.cpp
@@ -15,10 +15,12 @@
 #error setjmp not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::jmp_buf jb;
     ((void)jb); // Prevent unused warning
     static_assert((std::is_same<decltype(std::longjmp(jb, 0)), void>::value),
                   "std::is_same<decltype(std::longjmp(jb, 0)), void>::value");
+
+  return 0;
 }
Index: test/std/language.support/support.runtime/csignal.pass.cpp
===================================================================
--- test/std/language.support/support.runtime/csignal.pass.cpp
+++ test/std/language.support/support.runtime/csignal.pass.cpp
@@ -47,11 +47,13 @@
 #error SIGTERM not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::sig_atomic_t sig = 0;
     ((void)sig);
     typedef void (*func)(int);
     static_assert((std::is_same<decltype(std::signal(0, (func)0)), func>::value), "");
     static_assert((std::is_same<decltype(std::raise(0)), int>::value), "");
+
+  return 0;
 }
Index: test/std/language.support/support.runtime/cstdarg.pass.cpp
===================================================================
--- test/std/language.support/support.runtime/cstdarg.pass.cpp
+++ test/std/language.support/support.runtime/cstdarg.pass.cpp
@@ -30,8 +30,10 @@
 #error va_start not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::va_list va;
     ((void)va);
+
+  return 0;
 }
Index: test/std/language.support/support.runtime/cstdbool.pass.cpp
===================================================================
--- test/std/language.support/support.runtime/cstdbool.pass.cpp
+++ test/std/language.support/support.runtime/cstdbool.pass.cpp
@@ -26,6 +26,8 @@
 #error false should not be defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.runtime/cstdlib.pass.cpp
===================================================================
--- test/std/language.support/support.runtime/cstdlib.pass.cpp
+++ test/std/language.support/support.runtime/cstdlib.pass.cpp
@@ -49,7 +49,7 @@
     ((void) obj);
 };
 
-int main()
+int main(int, char**)
 {
     std::size_t s = 0;
     ((void)s);
@@ -108,4 +108,6 @@
     static_assert((std::is_same<decltype(std::wctomb(pc,L' ')), int>::value), "");
     static_assert((std::is_same<decltype(std::mbstowcs(pw,"",0)), std::size_t>::value), "");
     static_assert((std::is_same<decltype(std::wcstombs(pc,pwc,0)), std::size_t>::value), "");
+
+  return 0;
 }
Index: test/std/language.support/support.runtime/ctime.pass.cpp
===================================================================
--- test/std/language.support/support.runtime/ctime.pass.cpp
+++ test/std/language.support/support.runtime/ctime.pass.cpp
@@ -26,7 +26,7 @@
 #endif
 #endif
 
-int main()
+int main(int, char**)
 {
     std::clock_t c = 0;
     std::size_t s = 0;
@@ -58,4 +58,6 @@
     ((void)c1); // Prevent unused warning
     ((void)c2); // Prevent unused warning
     static_assert((std::is_same<decltype(std::strftime(c1,s,c2,&tm)), std::size_t>::value), "");
+
+  return 0;
 }
Index: test/std/language.support/support.start.term/quick_exit.pass.cpp
===================================================================
--- test/std/language.support/support.start.term/quick_exit.pass.cpp
+++ test/std/language.support/support.start.term/quick_exit.pass.cpp
@@ -13,10 +13,12 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_QUICK_EXIT
     std::at_quick_exit(f);
     std::quick_exit(0);
 #endif
+
+  return 0;
 }
Index: test/std/language.support/support.start.term/quick_exit_check1.fail.cpp
===================================================================
--- test/std/language.support/support.start.term/quick_exit_check1.fail.cpp
+++ test/std/language.support/support.start.term/quick_exit_check1.fail.cpp
@@ -15,11 +15,13 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_QUICK_EXIT
     std::at_quick_exit(f);
 #else
 #error
 #endif
+
+  return 0;
 }
Index: test/std/language.support/support.start.term/quick_exit_check2.fail.cpp
===================================================================
--- test/std/language.support/support.start.term/quick_exit_check2.fail.cpp
+++ test/std/language.support/support.start.term/quick_exit_check2.fail.cpp
@@ -14,11 +14,13 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_QUICK_EXIT
     std::quick_exit(0);
 #else
 #error
 #endif
+
+  return 0;
 }
Index: test/std/language.support/support.types/byte.pass.cpp
===================================================================
--- test/std/language.support/support.types/byte.pass.cpp
+++ test/std/language.support/support.types/byte.pass.cpp
@@ -30,4 +30,6 @@
 // The standard doesn't outright say this, but it's pretty clear that it has to be true.
 static_assert(sizeof(std::byte) == 1, "" );
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/language.support/support.types/byteops/and.assign.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/and.assign.pass.cpp
+++ test/std/language.support/support.types/byteops/and.assign.pass.cpp
@@ -20,7 +20,7 @@
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
@@ -35,4 +35,6 @@
     static_assert(std::to_integer<int>(test(b8, b1)) == 0, "");
     static_assert(std::to_integer<int>(test(b9, b1)) == 1, "");
     static_assert(std::to_integer<int>(test(b9, b8)) == 8, "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/and.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/and.pass.cpp
+++ test/std/language.support/support.types/byteops/and.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr byte operator&(byte l, byte r) noexcept;
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
     constexpr std::byte b9{static_cast<std::byte>(9)};
@@ -27,4 +27,6 @@
     static_assert(std::to_integer<int>(b8 & b1) ==  0, "");
     static_assert(std::to_integer<int>(b9 & b1) ==  1, "");
     static_assert(std::to_integer<int>(b9 & b8) ==  8, "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp
+++ test/std/language.support/support.types/byteops/enum_direct_init.pass.cpp
@@ -14,7 +14,9 @@
 // XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
 // XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
 
-int main () {
+int main(int, char**) {
   constexpr std::byte b{42};
   static_assert(std::to_integer<int>(b) == 42, "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
===================================================================
--- test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
+++ test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
@@ -25,6 +25,8 @@
     }
 
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1 = test(std::byte{1});
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
+++ test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
@@ -22,7 +22,7 @@
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b2{static_cast<std::byte>(2)};
     constexpr std::byte b3{static_cast<std::byte>(3)};
@@ -32,4 +32,6 @@
     static_assert(std::to_integer<int>(test(b2)) ==  8, "" );
     static_assert(std::to_integer<int>(test(b3)) == 12, "" );
 
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/lshift.fail.cpp
===================================================================
--- test/std/language.support/support.types/byteops/lshift.fail.cpp
+++ test/std/language.support/support.types/byteops/lshift.fail.cpp
@@ -16,7 +16,9 @@
 // These functions shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2 = b1 << 2.0f;
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/lshift.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/lshift.pass.cpp
+++ test/std/language.support/support.types/byteops/lshift.pass.cpp
@@ -16,7 +16,7 @@
 // These functions shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b3{static_cast<std::byte>(3)};
 
@@ -26,4 +26,6 @@
     static_assert(std::to_integer<int>(b1 << 2) ==   4, "");
     static_assert(std::to_integer<int>(b3 << 4) ==  48, "");
     static_assert(std::to_integer<int>(b3 << 6) == 192, "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/not.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/not.pass.cpp
+++ test/std/language.support/support.types/byteops/not.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr byte operator~(byte b) noexcept;
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2{static_cast<std::byte>(2)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
@@ -23,4 +23,6 @@
     static_assert(std::to_integer<int>(~b1) == 254, "");
     static_assert(std::to_integer<int>(~b2) == 253, "");
     static_assert(std::to_integer<int>(~b8) == 247, "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/or.assign.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/or.assign.pass.cpp
+++ test/std/language.support/support.types/byteops/or.assign.pass.cpp
@@ -20,7 +20,7 @@
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2{static_cast<std::byte>(2)};
@@ -36,4 +36,6 @@
     static_assert(std::to_integer<int>(test(b8, b1)) ==  9, "");
     static_assert(std::to_integer<int>(test(b8, b2)) == 10, "");
 
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/or.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/or.pass.cpp
+++ test/std/language.support/support.types/byteops/or.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr byte operator|(byte l, byte r) noexcept;
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2{static_cast<std::byte>(2)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
@@ -27,4 +27,6 @@
     static_assert(std::to_integer<int>(b2 | b1) ==  3, "");
     static_assert(std::to_integer<int>(b8 | b1) ==  9, "");
     static_assert(std::to_integer<int>(b8 | b2) == 10, "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
===================================================================
--- test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
+++ test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
@@ -25,6 +25,8 @@
     }
 
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1 = test(std::byte{1});
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
+++ test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
@@ -22,7 +22,7 @@
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b16{static_cast<std::byte>(16)};
     constexpr std::byte b192{static_cast<std::byte>(192)};
@@ -31,4 +31,6 @@
 
     static_assert(std::to_integer<int>(test(b16))  ==  4, "" );
     static_assert(std::to_integer<int>(test(b192)) == 48, "" );
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/rshift.fail.cpp
===================================================================
--- test/std/language.support/support.types/byteops/rshift.fail.cpp
+++ test/std/language.support/support.types/byteops/rshift.fail.cpp
@@ -16,7 +16,9 @@
 // These functions shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2 = b1 >> 2.0f;
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/rshift.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/rshift.pass.cpp
+++ test/std/language.support/support.types/byteops/rshift.pass.cpp
@@ -22,7 +22,7 @@
     }
 
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b100{static_cast<std::byte>(100)};
     constexpr std::byte b115{static_cast<std::byte>(115)};
 
@@ -33,4 +33,6 @@
     static_assert(std::to_integer<int>(b115 >> 3) ==  14, "");
     static_assert(std::to_integer<int>(b115 >> 6) ==   1, "");
 
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/to_integer.fail.cpp
===================================================================
--- test/std/language.support/support.types/byteops/to_integer.fail.cpp
+++ test/std/language.support/support.types/byteops/to_integer.fail.cpp
@@ -16,7 +16,9 @@
 // This function shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     auto f = std::to_integer<float>(b1);
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/to_integer.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/to_integer.pass.cpp
+++ test/std/language.support/support.types/byteops/to_integer.pass.cpp
@@ -16,7 +16,7 @@
 // This function shall not participate in overload resolution unless
 //   is_integral_v<IntegerType> is true.
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b3{static_cast<std::byte>(3)};
 
@@ -27,4 +27,6 @@
 
     static_assert(std::to_integer<int>(b1) == 1, "");
     static_assert(std::to_integer<int>(b3) == 3, "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/xor.assign.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/xor.assign.pass.cpp
+++ test/std/language.support/support.types/byteops/xor.assign.pass.cpp
@@ -20,7 +20,7 @@
     }
 
 
-int main () {
+int main(int, char**) {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
@@ -35,4 +35,6 @@
     static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
     static_assert(std::to_integer<int>(test(b9, b1)) == 8, "");
     static_assert(std::to_integer<int>(test(b9, b8)) == 1, "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/byteops/xor.pass.cpp
===================================================================
--- test/std/language.support/support.types/byteops/xor.pass.cpp
+++ test/std/language.support/support.types/byteops/xor.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr byte operator^(byte l, byte r) noexcept;
 
-int main () {
+int main(int, char**) {
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
     constexpr std::byte b9{static_cast<std::byte>(9)};
@@ -27,4 +27,6 @@
     static_assert(std::to_integer<int>(b8 ^ b1) == 9, "");
     static_assert(std::to_integer<int>(b9 ^ b1) == 8, "");
     static_assert(std::to_integer<int>(b9 ^ b8) == 1, "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/max_align_t.pass.cpp
===================================================================
--- test/std/language.support/support.types/max_align_t.pass.cpp
+++ test/std/language.support/support.types/max_align_t.pass.cpp
@@ -15,7 +15,7 @@
 #include <stdio.h>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 
 #if TEST_STD_VER > 17
@@ -40,4 +40,6 @@
                   std::alignment_of<void*>::value,
                   "std::alignment_of<std::max_align_t>::value >= "
                   "std::alignment_of<void*>::value");
+
+  return 0;
 }
Index: test/std/language.support/support.types/null.pass.cpp
===================================================================
--- test/std/language.support/support.types/null.pass.cpp
+++ test/std/language.support/support.types/null.pass.cpp
@@ -12,6 +12,8 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/language.support/support.types/nullptr_t.pass.cpp
===================================================================
--- test/std/language.support/support.types/nullptr_t.pass.cpp
+++ test/std/language.support/support.types/nullptr_t.pass.cpp
@@ -74,7 +74,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     static_assert(sizeof(std::nullptr_t) == sizeof(void*),
                   "sizeof(std::nullptr_t) == sizeof(void*)");
@@ -103,4 +103,6 @@
         test_comparisons<void(*)()>();
     }
     test_nullptr_conversions();
+
+  return 0;
 }
Index: test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp
===================================================================
--- test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp
+++ test/std/language.support/support.types/nullptr_t_integral_cast.fail.cpp
@@ -10,7 +10,9 @@
 
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     std::ptrdiff_t i = static_cast<std::ptrdiff_t>(nullptr);
+
+  return 0;
 }
Index: test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp
===================================================================
--- test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp
+++ test/std/language.support/support.types/nullptr_t_integral_cast.pass.cpp
@@ -16,8 +16,10 @@
 #include <cstddef>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ptrdiff_t i = reinterpret_cast<std::ptrdiff_t>(nullptr);
     assert(i == 0);
+
+  return 0;
 }
Index: test/std/language.support/support.types/offsetof.pass.cpp
===================================================================
--- test/std/language.support/support.types/offsetof.pass.cpp
+++ test/std/language.support/support.types/offsetof.pass.cpp
@@ -21,7 +21,9 @@
     int x;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert(noexcept(offsetof(A, x)), "");
+
+  return 0;
 }
Index: test/std/language.support/support.types/ptrdiff_t.pass.cpp
===================================================================
--- test/std/language.support/support.types/ptrdiff_t.pass.cpp
+++ test/std/language.support/support.types/ptrdiff_t.pass.cpp
@@ -15,7 +15,7 @@
 //  2. be the same sizeof as void*.
 //  3. be a signed integral.
 
-int main()
+int main(int, char**)
 {
     static_assert(sizeof(std::ptrdiff_t) == sizeof(void*),
                   "sizeof(std::ptrdiff_t) == sizeof(void*)");
@@ -23,4 +23,6 @@
                   "std::is_signed<std::ptrdiff_t>::value");
     static_assert(std::is_integral<std::ptrdiff_t>::value,
                   "std::is_integral<std::ptrdiff_t>::value");
+
+  return 0;
 }
Index: test/std/language.support/support.types/size_t.pass.cpp
===================================================================
--- test/std/language.support/support.types/size_t.pass.cpp
+++ test/std/language.support/support.types/size_t.pass.cpp
@@ -15,7 +15,7 @@
 //  2. be the same sizeof as void*.
 //  3. be an unsigned integral.
 
-int main()
+int main(int, char**)
 {
     static_assert(sizeof(std::size_t) == sizeof(void*),
                   "sizeof(std::size_t) == sizeof(void*)");
@@ -23,4 +23,6 @@
                   "std::is_unsigned<std::size_t>::value");
     static_assert(std::is_integral<std::size_t>::value,
                   "std::is_integral<std::size_t>::value");
+
+  return 0;
 }
Index: test/std/localization/c.locales/clocale.pass.cpp
===================================================================
--- test/std/localization/c.locales/clocale.pass.cpp
+++ test/std/localization/c.locales/clocale.pass.cpp
@@ -43,7 +43,7 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::lconv lc;
     ((void)lc); // Prevent unused warning
@@ -51,4 +51,6 @@
     static_assert((std::is_same<decltype(std::setlocale(0, "")), char*>::value), "");
 #endif
     static_assert((std::is_same<decltype(std::localeconv()), std::lconv*>::value), "");
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate.byname/compare.pass.cpp
@@ -32,7 +32,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -68,4 +68,6 @@
                              s3.data(), s3.data() + s3.size()) == 1);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate.byname/hash.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     std::locale l(LOCALE_en_US_UTF_8);
     {
@@ -39,4 +39,6 @@
         assert(f.hash(x1.data(), x1.data() + x1.size())
             != f.hash(x2.data(), x2.data() + x2.size()));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate.byname/transform.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -53,4 +53,6 @@
             assert(f.transform(x.data(), x.data() + x.size()) == x);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate.byname/types.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     std::locale l(LOCALE_en_US_UTF_8);
     {
@@ -43,4 +43,6 @@
         assert(&std::use_facet<std::collate<wchar_t> >(l)
             == &std::use_facet<std::collate_byname<wchar_t> >(l));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate/ctor.pass.cpp
@@ -31,7 +31,7 @@
 
 template <class C> int my_facet<C>::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet<char>);
@@ -63,4 +63,6 @@
         assert(my_facet<wchar_t>::count == 1);
     }
     assert(my_facet<wchar_t>::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/compare.pass.cpp
@@ -16,7 +16,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -45,4 +45,6 @@
         assert(f.compare(ib+1, ib+3, ia, ia+sa) == 1);
         assert(f.compare(ia, ia+3, ib, ib+3) == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/hash.pass.cpp
@@ -18,7 +18,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -35,4 +35,6 @@
         assert(f.hash(x1.data(), x1.data() + x1.size())
             != f.hash(x2.data(), x2.data() + x2.size()));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.members/transform.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@
         const std::collate<wchar_t>& f = std::use_facet<std::collate<wchar_t> >(l);
         assert(f.transform(x.data(), x.data() + x.size()) == x);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate/locale.collate.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp
+++ test/std/localization/locale.categories/category.collate/locale.collate/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -47,4 +47,6 @@
         static_assert((std::is_same<std::collate<wchar_t>::string_type, std::wstring>::value), "");
         static_assert((std::is_base_of<std::locale::facet, std::collate<wchar_t> >::value), "");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp
+++ test/std/localization/locale.categories/category.collate/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
@@ -38,7 +38,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     assert(std::ctype_base::space);
     assert(std::ctype_base::print);
@@ -74,4 +74,6 @@
     test(std::ctype_base::blank);
     test(std::ctype_base::alnum);
     test(std::ctype_base::graph);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.dtor/dtor.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new std::ctype<char>);
@@ -36,4 +36,6 @@
         assert(globalMemCounter.checkDeleteArrayCalledEq(0));
     }
     assert(globalMemCounter.checkDeleteArrayCalledEq(1));
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/ctor.pass.cpp
@@ -29,7 +29,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -46,4 +46,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -55,4 +55,6 @@
         assert(f.is(F::graph, '.'));
         assert(!f.is(F::graph,  '\x07'));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/is_many.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -114,4 +114,6 @@
         assert( (m[5] & F::alnum));
         assert( (m[5] & F::graph));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@
         assert(f.narrow('a', '*') == 'a');
         assert(f.narrow('1', '*') == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/narrow_many.pass.cpp
@@ -17,7 +17,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -34,4 +34,6 @@
         assert(v[4] == 'a');
         assert(v[5] == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_is.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -40,4 +40,6 @@
         assert(f.scan_is(F::alnum, in.data(), in.data() + in.size()) - in.data() == 1);
         assert(f.scan_is(F::graph, in.data(), in.data() + in.size()) - in.data() == 1);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/scan_not.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -40,4 +40,6 @@
         assert(f.scan_not(F::alnum, in.data(), in.data() + in.size()) - in.data() == 0);
         assert(f.scan_not(F::graph, in.data(), in.data() + in.size()) - in.data() == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/table.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::ctype<char> F;
     {
@@ -29,4 +29,6 @@
         const F& f = std::use_facet<F>(l);
         assert(f.table() == table);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@
         assert(f.tolower('a') == 'a');
         assert(f.tolower('1') == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/tolower_many.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -32,4 +32,6 @@
         assert(in[4] == 'a');
         assert(in[5] == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@
         assert(f.toupper('a') == 'A');
         assert(f.toupper('1') == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/toupper_many.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -32,4 +32,6 @@
         assert(in[4] == 'A');
         assert(in[5] == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@
         assert(f.widen('a') == 'a');
         assert(f.widen('1') == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.members/widen_many.pass.cpp
@@ -17,7 +17,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -34,4 +34,6 @@
         assert(v[4] == 'a');
         assert(v[5] == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.statics/classic_table.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::ctype<char> F;
     assert(F::classic_table() != 0);
@@ -55,4 +55,6 @@
         assert(((p[i] & ~set) & defined) == 0);   // no extra ones
     }
 
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/facet.ctype.char.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/facet.ctype.special/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -35,4 +35,6 @@
         static_assert((std::is_base_of<std::ctype_base, std::ctype<char> >::value), "");
         static_assert((std::is_base_of<std::locale::facet, std::ctype<char> >::value), "");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
@@ -36,7 +36,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet(LOCALE_en_US));
@@ -68,4 +68,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.pass.cpp
@@ -34,7 +34,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet("en_US"));
@@ -66,4 +66,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.pass.cpp
@@ -34,7 +34,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet("en_US"));
@@ -66,4 +66,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_wchar_t.pass.cpp
@@ -38,7 +38,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet(LOCALE_en_US_UTF_8));
@@ -70,4 +70,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_base.pass.cpp
@@ -17,10 +17,12 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::codecvt_base::ok == 0);
     assert(std::codecvt_base::partial == 1);
     assert(std::codecvt_base::error == 2);
     assert(std::codecvt_base::noconv == 3);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.pass.cpp
@@ -35,7 +35,7 @@
 
 //#endif
 
-int main()
+int main(int, char**)
 {
 //#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     {
@@ -54,4 +54,6 @@
     }
     assert(my_facet::count == 0);
 //#endif
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.pass.cpp
@@ -35,7 +35,7 @@
 
 //#endif
 
-int main()
+int main(int, char**)
 {
 //#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     {
@@ -54,4 +54,6 @@
     }
     assert(my_facet::count == 0);
 //#endif
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_wchar_t.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(!f.always_noconv());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.pass.cpp
@@ -21,7 +21,7 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const char from[] = "some text";
@@ -36,4 +36,6 @@
     assert(to_next - to == 9);
     for (unsigned i = 0; i < 9; ++i)
         assert(to[i] == from[i]);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.pass.cpp
@@ -17,7 +17,7 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -28,4 +28,6 @@
     assert(f.length(mbs, from, from+10, 9) == 9);
     assert(f.length(mbs, from, from+10, 10) == 10);
     assert(f.length(mbs, from, from+10, 100) == 10);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 4);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.pass.cpp
@@ -23,7 +23,7 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -41,4 +41,6 @@
         for (unsigned i = 0; i < 9; ++i)
             assert(to[i] == from[i]);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.pass.cpp
@@ -20,7 +20,7 @@
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     std::vector<char> to(3);
@@ -29,4 +29,6 @@
     char* to_next = 0;
     assert(f.unshift(mbs, to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(to_next == to.data());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(!f.always_noconv());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
@@ -21,7 +21,7 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const char from[] = "some text";
@@ -36,4 +36,6 @@
     assert(to_next - to == 9);
     for (unsigned i = 0; i < 9; ++i)
         assert(to[i] == static_cast<char32_t>(from[i]));
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.pass.cpp
@@ -17,7 +17,7 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -28,4 +28,6 @@
     assert(f.length(mbs, from, from+10, 9) == 9);
     assert(f.length(mbs, from, from+10, 10) == 10);
     assert(f.length(mbs, from, from+10, 100) == 10);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 4);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
@@ -23,7 +23,7 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -41,4 +41,6 @@
         for (unsigned i = 0; i < 9; ++i)
             assert(static_cast<char32_t>(to[i]) == from[i]);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.pass.cpp
@@ -20,7 +20,7 @@
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     std::vector<char> to(3);
@@ -29,4 +29,6 @@
     char* to_next = 0;
     assert(f.unshift(mbs, to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(to_next == to.data());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_always_noconv.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.always_noconv());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_encoding.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 1);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_in.pass.cpp
@@ -21,7 +21,7 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const std::basic_string<F::intern_type> from("some text");
@@ -34,4 +34,6 @@
                      to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(from_next == from.data());
     assert(to_next == to.data());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_length.pass.cpp
@@ -17,7 +17,7 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -28,4 +28,6 @@
     assert(f.length(mbs, from, from+10, 10) == 10);
     assert(f.length(mbs, from, from+10, 11) == 10);
     assert(f.length(mbs, from, from+10, 100) == 10);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_max_length.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 1);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_out.pass.cpp
@@ -21,7 +21,7 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const std::basic_string<F::intern_type> from("some text");
@@ -34,4 +34,6 @@
                       to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(from_next == from.data());
     assert(to_next == to.data());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char_unshift.pass.cpp
@@ -20,7 +20,7 @@
 
 typedef std::codecvt<char, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     std::vector<char> to(3);
@@ -29,4 +29,6 @@
     char* to_next = 0;
     assert(f.unshift(mbs, to.data(), to.data() + to.size(), to_next) == F::noconv);
     assert(to_next == to.data());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp
@@ -20,7 +20,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<char32_t, char, std::mbstate_t> F32_8;
     typedef std::codecvt<char16_t, char, std::mbstate_t> F16_8;
@@ -123,4 +123,6 @@
             assert(c32 == c32x);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_always_noconv.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(!f.always_noconv());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_encoding.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 1);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp
@@ -22,7 +22,7 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const std::basic_string<F::extern_type> from("some text");
@@ -39,4 +39,6 @@
     assert(static_cast<std::size_t>(to_next - to.data()) == expected.size());
     assert(static_cast<std::size_t>(to_next - to.data()) == expected.size());
     assert(to == expected);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_length.pass.cpp
@@ -17,7 +17,7 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -28,4 +28,6 @@
     assert(f.length(mbs, from, from+10, 10) == 10);
     assert(f.length(mbs, from, from+10, 11) == 10);
     assert(f.length(mbs, from, from+10, 100) == 10);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_max_length.pass.cpp
@@ -17,9 +17,11 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 1);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp
@@ -23,7 +23,7 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
@@ -67,4 +67,6 @@
         assert(static_cast<std::size_t>(to_next - to.data()) == to.size()-1);
         assert(to.data() == std::string("some te"));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_unshift.pass.cpp
@@ -22,7 +22,7 @@
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     std::vector<F::extern_type> to(3);
@@ -31,4 +31,6 @@
     F::extern_type* to_next = 0;
     assert(f.unshift(mbs, to.data(), to.data() + to.size(), to_next) == F::ok);
     assert(to_next == to.data());
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char.pass.cpp
@@ -24,7 +24,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<char, char, std::mbstate_t> F;
     static_assert((std::is_base_of<std::locale::facet, F>::value), "");
@@ -37,4 +37,6 @@
     const F& f = std::use_facet<F>(l);
     ((void)f); // Prevent unused warning
     (void)F::id;
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp
@@ -24,7 +24,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<char16_t, char, std::mbstate_t> F;
     static_assert((std::is_base_of<std::locale::facet, F>::value), "");
@@ -37,4 +37,6 @@
     const F& f = std::use_facet<F>(l);
     (void)F::id;
     ((void)f);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp
@@ -24,7 +24,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<char32_t, char, std::mbstate_t> F;
     static_assert((std::is_base_of<std::locale::facet, F>::value), "");
@@ -37,4 +37,6 @@
     const F& f = std::use_facet<F>(l);
     (void)F::id;
     ((void)f);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.codecvt/types_wchar_t.pass.cpp
@@ -24,7 +24,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
     static_assert((std::is_base_of<std::locale::facet, F>::value), "");
@@ -37,4 +37,6 @@
     const F& f = std::use_facet<F>(l);
     ((void)f); // Prevent unused warning
     (void)F::id;
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_1.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -108,4 +108,6 @@
             assert(!f.is(F::upper, L'\x00DA'));
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/is_many.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -243,4 +243,6 @@
             assert( (m[6] & F::graph));
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/mask.pass.cpp
@@ -16,7 +16,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l("C");
@@ -49,4 +49,6 @@
             assert( cf.is(CF::alpha,  'a'));
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_1.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::string(LOCALE_fr_CA_ISO8859_1));
@@ -52,4 +52,6 @@
             assert(f.narrow(L'\xDA', '*') == '*');
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/narrow_many.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_fr_CA_ISO8859_1);
@@ -60,4 +60,6 @@
             assert(v[6] == '*');
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_is.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -67,4 +67,6 @@
             assert(f.scan_is(F::graph, in.data(), in.data() + in.size()) - in.data() == 2);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/scan_not.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -67,4 +67,6 @@
             assert(f.scan_not(F::graph, in.data(), in.data() + in.size()) - in.data() == 0);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_1.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -88,4 +88,6 @@
             assert(f.tolower(L'\xFA') == L'\xFA');
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/tolower_many.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -94,4 +94,6 @@
             assert(in[6] == L'1');
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_1.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -90,4 +90,6 @@
             assert(f.toupper(L'\xFA') == L'\xFA');
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/toupper_many.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -94,4 +94,6 @@
             assert(in[6] == L'1');
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/types.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -56,4 +56,6 @@
                 == &std::use_facet<std::ctype_byname<wchar_t> >(l));
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_1.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -61,4 +61,6 @@
 #endif
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype.byname/widen_many.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(LOCALE_en_US_UTF_8);
@@ -67,4 +67,6 @@
 #endif
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/ctor.pass.cpp
@@ -30,7 +30,7 @@
 
 template <class C> int my_facet<C>::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet<wchar_t>);
@@ -47,4 +47,6 @@
         assert(my_facet<wchar_t>::count == 1);
     }
     assert(my_facet<wchar_t>::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -55,4 +55,6 @@
         assert(f.is(F::graph, L'.'));
         assert(!f.is(F::graph,  L'\x07'));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/is_many.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -114,4 +114,6 @@
         assert( (m[5] & F::alnum));
         assert( (m[5] & F::graph));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@
         assert(f.narrow(L'a', '*') == 'a');
         assert(f.narrow(L'1', '*') == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/narrow_many.pass.cpp
@@ -17,7 +17,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -34,4 +34,6 @@
         assert(v[4] == 'a');
         assert(v[5] == '1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_is.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -40,4 +40,6 @@
         assert(f.scan_is(F::alnum, in.data(), in.data() + in.size()) - in.data() == 1);
         assert(f.scan_is(F::graph, in.data(), in.data() + in.size()) - in.data() == 1);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/scan_not.pass.cpp
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -40,4 +40,6 @@
         assert(f.scan_not(F::alnum, in.data(), in.data() + in.size()) - in.data() == 0);
         assert(f.scan_not(F::graph, in.data(), in.data() + in.size()) - in.data() == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@
         assert(f.tolower(L'a') == L'a');
         assert(f.tolower(L'1') == L'1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/tolower_many.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -32,4 +32,6 @@
         assert(in[4] == L'a');
         assert(in[5] == L'1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@
         assert(f.toupper(L'a') == L'A');
         assert(f.toupper(L'1') == L'1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/toupper_many.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -32,4 +32,6 @@
         assert(in[4] == L'A');
         assert(in[5] == L'1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_1.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -29,4 +29,6 @@
         assert(f.widen('a') == L'a');
         assert(f.widen('1') == L'1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.members/widen_many.pass.cpp
@@ -17,7 +17,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -34,4 +34,6 @@
         assert(v[4] == L'a');
         assert(v[5] == L'1');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/locale.ctype.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp
+++ test/std/localization/locale.categories/category.ctype/locale.ctype/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -35,4 +35,6 @@
         static_assert((std::is_base_of<std::ctype_base, std::ctype<wchar_t> >::value), "");
         static_assert((std::is_base_of<std::locale::facet, std::ctype<wchar_t> >::value), "");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp
+++ test/std/localization/locale.categories/category.messages/locale.messages.byname/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.messages/locale.messages/ctor.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp
+++ test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.members/not_testable.pass.cpp
@@ -28,6 +28,8 @@
         : std::messages<CharT>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.messages/locale.messages/locale.messages.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp
+++ test/std/localization/locale.categories/category.messages/locale.messages/messages_base.pass.cpp
@@ -17,7 +17,9 @@
 #include <locale>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::messages_base mb;
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp
+++ test/std/localization/locale.categories/category.messages/locale.messages/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <locale>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::messages<char> >::value), "");
     static_assert((std::is_base_of<std::messages_base, std::messages<char> >::value), "");
@@ -30,4 +30,6 @@
     static_assert((std::is_same<std::messages<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::messages<char>::string_type, std::string>::value), "");
     static_assert((std::is_same<std::messages<wchar_t>::string_type, std::wstring>::value), "");
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp
+++ test/std/localization/locale.categories/category.messages/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.get/ctor.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
@@ -43,7 +43,7 @@
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
@@ -719,4 +719,6 @@
             assert(err == std::ios_base::failbit);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
@@ -76,7 +76,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_fr_FR_UTF_8);
@@ -753,4 +753,6 @@
             assert(ex == 123456789);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
@@ -55,7 +55,7 @@
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_ru_RU_UTF_8);
@@ -735,4 +735,6 @@
             assert(ex == -123456789);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
@@ -49,7 +49,7 @@
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_zh_CN_UTF_8);
@@ -725,4 +725,6 @@
             assert(err == std::ios_base::failbit);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
@@ -43,7 +43,7 @@
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
@@ -727,4 +727,6 @@
             assert(ex == L"");
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.get/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <locale>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::money_get<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::money_get<wchar_t> >::value), "");
@@ -30,4 +30,6 @@
     static_assert((std::is_same<std::money_get<wchar_t>::iter_type, std::istreambuf_iterator<wchar_t> >::value), "");
     static_assert((std::is_same<std::money_get<char>::string_type, std::string>::value), "");
     static_assert((std::is_same<std::money_get<wchar_t>::string_type, std::wstring>::value), "");
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.put/ctor.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_en_US.pass.cpp
@@ -43,7 +43,7 @@
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
@@ -490,4 +490,6 @@
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_fr_FR.pass.cpp
@@ -78,7 +78,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_fr_FR_UTF_8);
@@ -524,4 +524,6 @@
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_ru_RU.pass.cpp
@@ -55,7 +55,7 @@
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_ru_RU_UTF_8);
@@ -501,4 +501,6 @@
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_long_double_zh_CN.pass.cpp
@@ -49,7 +49,7 @@
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_zh_CN_UTF_8);
@@ -495,4 +495,6 @@
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.members/put_string_en_US.pass.cpp
@@ -43,7 +43,7 @@
         : Fw(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::string loc_name(LOCALE_en_US_UTF_8);
@@ -490,4 +490,6 @@
         assert(ios.width() == 0);
     }
 }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.put/locale.money.put.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.money.put/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <locale>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::money_put<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::money_put<wchar_t> >::value), "");
@@ -30,4 +30,6 @@
     static_assert((std::is_same<std::money_put<wchar_t>::iter_type, std::ostreambuf_iterator<wchar_t> >::value), "");
     static_assert((std::is_same<std::money_put<char>::string_type, std::string>::value), "");
     static_assert((std::is_same<std::money_put<wchar_t>::string_type, std::wstring>::value), "");
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
@@ -75,7 +75,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -179,4 +179,6 @@
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.curr_symbol() == L"CNY ");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/decimal_point.pass.cpp
@@ -56,7 +56,7 @@
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -153,4 +153,6 @@
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.decimal_point() == L'.');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/frac_digits.pass.cpp
@@ -55,7 +55,7 @@
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -141,4 +141,6 @@
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.frac_digits() == 2);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/grouping.pass.cpp
@@ -60,7 +60,7 @@
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     // Monetary grouping strings may be terminated with 0 or CHAR_MAX, defining
     // how the grouping is repeated.
@@ -149,4 +149,6 @@
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.grouping() == "\3");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/neg_format.pass.cpp
@@ -60,7 +60,7 @@
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -226,4 +226,6 @@
         assert(p.field[2] == std::money_base::none);
         assert(p.field[3] == std::money_base::value);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/negative_sign.pass.cpp
@@ -55,7 +55,7 @@
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -141,4 +141,6 @@
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.negative_sign() == L"-");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/pos_format.pass.cpp
@@ -60,7 +60,7 @@
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -226,4 +226,6 @@
         assert(p.field[2] == std::money_base::none);
         assert(p.field[3] == std::money_base::value);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/positive_sign.pass.cpp
@@ -55,7 +55,7 @@
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -141,4 +141,6 @@
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.positive_sign() == L"");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/thousands_sep.pass.cpp
@@ -59,7 +59,7 @@
         : std::moneypunct_byname<wchar_t, true>(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f("C", 1);
@@ -170,4 +170,6 @@
         Fwt f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.thousands_sep() == L',');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/ctor.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/curr_symbol.pass.cpp
@@ -53,7 +53,7 @@
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@
         Fwt f(1);
         assert(f.curr_symbol() == std::wstring());
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/decimal_point.pass.cpp
@@ -53,7 +53,7 @@
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@
         Fwt f(1);
         assert(f.decimal_point() == std::numeric_limits<wchar_t>::max());
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/frac_digits.pass.cpp
@@ -53,7 +53,7 @@
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@
         Fwt f(1);
         assert(f.frac_digits() == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/grouping.pass.cpp
@@ -53,7 +53,7 @@
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@
         Fwt f(1);
         assert(f.grouping() == std::string());
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/neg_format.pass.cpp
@@ -50,7 +50,7 @@
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -84,4 +84,6 @@
         assert(p.field[2] == std::money_base::none);
         assert(p.field[3] == std::money_base::value);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/negative_sign.pass.cpp
@@ -54,7 +54,7 @@
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -72,4 +72,6 @@
         Fwt f(1);
         assert(f.negative_sign() == L"-");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/pos_format.pass.cpp
@@ -50,7 +50,7 @@
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -84,4 +84,6 @@
         assert(p.field[2] == std::money_base::none);
         assert(p.field[3] == std::money_base::value);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/positive_sign.pass.cpp
@@ -53,7 +53,7 @@
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@
         Fwt f(1);
         assert(f.positive_sign() == std::wstring());
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.members/thousands_sep.pass.cpp
@@ -53,7 +53,7 @@
         : std::moneypunct<wchar_t, true>(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         Fnf f(1);
@@ -71,4 +71,6 @@
         Fwt f(1);
         assert(f.thousands_sep() == std::numeric_limits<wchar_t>::max());
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/locale.moneypunct.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/money_base.pass.cpp
@@ -18,7 +18,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::money_base mb; ((void)mb);
     static_assert(std::money_base::none == 0, "");
@@ -29,4 +29,6 @@
     static_assert(sizeof(std::money_base::pattern) == 4, "");
     std::money_base::pattern p;
     p.field[0] = std::money_base::none;
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
@@ -29,7 +29,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::moneypunct<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::moneypunct<wchar_t> >::value), "");
@@ -44,4 +44,6 @@
     test(std::moneypunct<char, true>::intl);
     test(std::moneypunct<wchar_t, false>::intl);
     test(std::moneypunct<wchar_t, true>::intl);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp
+++ test/std/localization/locale.categories/category.monetary/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/ctor.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_bool.pass.cpp
@@ -39,7 +39,7 @@
     virtual string_type do_falsename() const {return "no";}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -96,4 +96,6 @@
             assert(ex == "yes");
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp
@@ -17876,7 +17876,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -17886,4 +17886,6 @@
     test6();
     test7();
     test8();
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long.pass.cpp
@@ -39,7 +39,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -340,4 +340,6 @@
         assert(ex == "-***1_00_0");
         assert(ios.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp
@@ -26206,7 +26206,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -26246,4 +26246,6 @@
     {
         long double v = std::nan(""); ((void)v);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_long.pass.cpp
@@ -39,7 +39,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -340,4 +340,6 @@
         assert(ex == "-***1_00_0");
         assert(ios.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_pointer.pass.cpp
@@ -28,7 +28,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -45,4 +45,6 @@
         assert(rc > 0);
         assert(ex == expected_str);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long.pass.cpp
@@ -39,7 +39,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -343,4 +343,6 @@
                                                  : "18_446_744_073_709_550_61_6"));
         assert(ios.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_unsigned_long_long.pass.cpp
@@ -39,7 +39,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     {
@@ -340,4 +340,6 @@
         assert(ex == "18_446_744_073_709_550_61_6");
         assert(ios.width() == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.nm.put/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::num_put<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::num_put<wchar_t> >::value), "");
@@ -28,4 +28,6 @@
     static_assert((std::is_same<std::num_put<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::num_put<char>::iter_type, std::ostreambuf_iterator<char> >::value), "");
     static_assert((std::is_same<std::num_put<wchar_t>::iter_type, std::ostreambuf_iterator<wchar_t> >::value), "");
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/ctor.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
@@ -51,7 +51,7 @@
     virtual string_type do_falsename() const {return "ab";}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -226,4 +226,6 @@
         assert(err == ios.goodbit);
         assert(b == true);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
@@ -48,7 +48,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -278,4 +278,6 @@
         assert(err == ios.goodbit);
         assert(std::abs(v - 3.14159265358979e+10)/3.14159265358979e+10 < 1.e-8);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
@@ -35,7 +35,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -208,4 +208,6 @@
         assert(err == ios.goodbit);
         assert(v == 2);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
@@ -41,7 +41,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -517,4 +517,6 @@
         assert(err == ios.failbit);
         assert(v == std::numeric_limits<long>::max());
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
@@ -35,7 +35,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -267,4 +267,6 @@
         assert(err == ios.goodbit);
         assert(v == 2);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
@@ -40,7 +40,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -102,4 +102,6 @@
         const long long expect = 0x8000000000000000LL;
         assert(v == expect);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
@@ -29,7 +29,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -57,4 +57,6 @@
         assert(err == ios.goodbit);
         assert(p == (void*)0x73);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
@@ -40,7 +40,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -79,4 +79,6 @@
         assert(err == ios.goodbit);
         assert(v == 0xFFFFFFFF);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
@@ -40,7 +40,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -79,4 +79,6 @@
         assert(err == ios.goodbit);
         assert(v == 0xFFFFFFFF);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
@@ -40,7 +40,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -79,4 +79,6 @@
         assert(err == ios.goodbit);
         assert(v == 0xFFFFFFFFFFFFFFFFULL);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
@@ -40,7 +40,7 @@
     virtual std::string do_grouping() const {return std::string("\1\2\3");}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -79,4 +79,6 @@
         assert(err == ios.goodbit);
         assert(v == 0xFFFF);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_min_max.pass.cpp
@@ -51,7 +51,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     check_limits<short>();
     check_limits<unsigned short>();
@@ -61,4 +61,6 @@
     check_limits<unsigned long>();
     check_limits<long long>();
     check_limits<unsigned long long>();
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
@@ -148,7 +148,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_neg_one<long>();
     test_neg_one<long long>();
@@ -161,4 +161,6 @@
     test_negate<unsigned int>();
     test_negate<unsigned long>();
     test_negate<unsigned long long>();
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/locale.num.get/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::num_get<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::num_get<wchar_t> >::value), "");
@@ -28,4 +28,6 @@
     static_assert((std::is_same<std::num_get<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::num_get<char>::iter_type, std::istreambuf_iterator<char> >::value), "");
     static_assert((std::is_same<std::num_get<wchar_t>::iter_type, std::istreambuf_iterator<wchar_t> >::value), "");
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp
+++ test/std/localization/locale.categories/category.numeric/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
@@ -33,7 +33,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const my_facet f(LOCALE_en_US_UTF_8, 1);
@@ -51,4 +51,6 @@
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.date_order() == std::time_base::ymd);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
@@ -33,7 +33,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const my_facet f(LOCALE_en_US_UTF_8, 1);
@@ -51,4 +51,6 @@
         const my_facet f(LOCALE_zh_CN_UTF_8, 1);
         assert(f.date_order() == std::time_base::ymd);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
@@ -44,7 +44,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -98,4 +98,6 @@
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
@@ -44,7 +44,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -97,4 +97,6 @@
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
@@ -36,7 +36,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -71,4 +71,6 @@
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
@@ -45,7 +45,7 @@
         : F2(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -80,4 +80,6 @@
         assert(t.tm_mon == 5);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
@@ -42,7 +42,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -167,4 +167,6 @@
         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
@@ -42,7 +42,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -169,4 +169,6 @@
         assert(t.tm_hour == 23);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
@@ -37,7 +37,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -90,4 +90,6 @@
         assert(t.tm_sec == 15);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
@@ -37,7 +37,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -90,4 +90,6 @@
         assert(t.tm_sec == 15);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
@@ -40,7 +40,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -87,4 +87,6 @@
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
@@ -40,7 +40,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -85,4 +85,6 @@
         assert(t.tm_wday == 1);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
@@ -36,7 +36,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -81,4 +81,6 @@
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
@@ -36,7 +36,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     std::ios ios(0);
     std::ios_base::iostate err;
@@ -81,4 +81,6 @@
         assert(t.tm_year == 109);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/ctor.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
@@ -26,8 +26,10 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     assert(f.date_order() == std::time_base::mdy);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
@@ -30,7 +30,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -47,4 +47,6 @@
         assert(t.tm_year == 105);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
@@ -30,7 +30,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -47,4 +47,6 @@
         assert(t.tm_year == 105);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
@@ -30,7 +30,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -64,4 +64,6 @@
         assert(t.tm_min == 27);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
@@ -30,7 +30,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -261,4 +261,6 @@
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::failbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
@@ -30,7 +30,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -261,4 +261,6 @@
         assert(t.tm_mon == 0);
         assert(err == std::ios_base::failbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
@@ -29,7 +29,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -301,4 +301,6 @@
         assert(i.base() == in+sizeof(in)-1);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
@@ -30,7 +30,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -113,4 +113,6 @@
 //         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
@@ -30,7 +30,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -113,4 +113,6 @@
 //         assert(t.tm_sec == 0);
         assert(err == std::ios_base::failbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
@@ -30,7 +30,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -216,4 +216,6 @@
         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
@@ -30,7 +30,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -216,4 +216,6 @@
         assert(t.tm_wday == 6);
         assert(err == std::ios_base::eofbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
@@ -29,7 +29,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     std::ios ios(0);
@@ -134,4 +134,6 @@
         assert(t.tm_year == 1099);
         assert(err == std::ios_base::goodbit);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/time_base.pass.cpp
@@ -17,7 +17,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::time_base::dateorder d = std::time_base::no_order;
     ((void)d); // Prevent unused warning
@@ -26,4 +26,6 @@
     assert(std::time_base::mdy == 2);
     assert(std::time_base::ymd == 3);
     assert(std::time_base::ydm == 4);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.get/types.pass.cpp
@@ -27,7 +27,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::time_get<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::time_get<wchar_t> >::value), "");
@@ -37,4 +37,6 @@
     static_assert((std::is_same<std::time_get<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::time_get<char>::iter_type, std::istreambuf_iterator<char> >::value), "");
     static_assert((std::is_same<std::time_get<wchar_t>::iter_type, std::istreambuf_iterator<wchar_t> >::value), "");
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.put.byname/put1.pass.cpp
@@ -45,7 +45,7 @@
         : F(nm, refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     char str[200];
     output_iterator<char*> iter;
@@ -77,4 +77,6 @@
         assert((ex == "Today is Samedi which is abbreviated Sam.")||
                (ex == "Today is samedi which is abbreviated sam." ));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.put/ctor.pass.cpp
@@ -31,7 +31,7 @@
 
 int my_facet::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet);
@@ -48,4 +48,6 @@
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put1.pass.cpp
@@ -27,7 +27,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     char str[200];
@@ -57,4 +57,6 @@
         std::string ex(str, iter.base());
         assert(ex == "The number of the month is 05.");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp
@@ -27,7 +27,7 @@
         : F(refs) {}
 };
 
-int main()
+int main(int, char**)
 {
     const my_facet f(1);
     char str[200];
@@ -328,4 +328,6 @@
         std::string ex(str, iter.base());
         assert(ex == "%");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp
+++ test/std/localization/locale.categories/category.time/locale.time.put/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <iterator>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::locale::facet, std::time_put<char> >::value), "");
     static_assert((std::is_base_of<std::locale::facet, std::time_put<wchar_t> >::value), "");
@@ -28,4 +28,6 @@
     static_assert((std::is_same<std::time_put<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::time_put<char>::iter_type, std::ostreambuf_iterator<char> >::value), "");
     static_assert((std::is_same<std::time_put<wchar_t>::iter_type, std::ostreambuf_iterator<wchar_t> >::value), "");
+
+  return 0;
 }
Index: test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp
+++ test/std/localization/locale.categories/category.time/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/decimal_point.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l("C");
@@ -61,4 +61,6 @@
             assert(np.decimal_point() == L',');
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/grouping.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l("C");
@@ -70,4 +70,6 @@
             assert(np.grouping() == group);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct.byname/thousands_sep.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l("C");
@@ -84,4 +84,6 @@
             assert(np.thousands_sep() == wsep);
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct/ctor.pass.cpp
@@ -30,7 +30,7 @@
 
 template <class C> int my_facet<C>::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l(std::locale::classic(), new my_facet<char>);
@@ -62,4 +62,6 @@
         assert(my_facet<wchar_t>::count == 1);
     }
     assert(my_facet<wchar_t>::count == 0);
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/decimal_point.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.decimal_point() == L'.');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/falsename.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.falsename() == std::wstring(L"false"));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/grouping.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.grouping() == std::string());
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/thousands_sep.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.thousands_sep() == L',');
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.members/truename.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -28,4 +28,6 @@
         const std::numpunct<C>& np = std::use_facet<std::numpunct<C> >(l);
         assert(np.truename() == std::wstring(L"true"));
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct/facet.numpunct.virtuals/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/locale.numpunct/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l = std::locale::classic();
     {
@@ -46,4 +46,6 @@
         static_assert((std::is_same<std::numpunct<wchar_t>::string_type, std::wstring>::value), "");
         static_assert((std::is_base_of<std::locale::facet, std::numpunct<wchar_t> >::value), "");
     }
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp
+++ test/std/localization/locale.categories/facet.numpunct/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp
+++ test/std/localization/locale.categories/facets.examples/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_mode.pass.cpp
@@ -18,11 +18,13 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::consume_header == 4);
     assert(std::generate_header == 2);
     assert(std::little_endian == 1);
     std::codecvt_mode e = std::consume_header;
     assert(e == 4);
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -38,4 +38,6 @@
         assert(globalMemCounter.checkOutstandingNewNotEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf16_always_noconv.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -41,4 +41,6 @@
         bool r = c.always_noconv();
         assert(r == false);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf16_encoding.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -41,4 +41,6 @@
         int r = c.encoding();
         assert(r == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf16_in.pass.cpp
@@ -24,7 +24,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<char32_t> C;
@@ -735,4 +735,6 @@
         assert(np == n+2);
         assert(w == 0x56);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf16_length.pass.cpp
@@ -22,7 +22,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -445,4 +445,6 @@
         r = c.length(m, n, n+2, 2);
         assert(r == 2);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf16_max_length.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -59,4 +59,6 @@
         int r = c.max_length();
         assert(r == 6);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf16_out.pass.cpp
@@ -346,7 +346,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   TestHelper<char32_t>::test();
   TestHelper<wchar_t>::test();
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf16_unshift.pass.cpp
@@ -23,7 +23,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf16<wchar_t> C;
@@ -52,4 +52,6 @@
         std::codecvt_base::result r = c.unshift(m, n, n+4, np);
         assert(r == std::codecvt_base::noconv);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -38,4 +38,6 @@
         assert(globalMemCounter.checkOutstandingNewNotEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_always_noconv.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -41,4 +41,6 @@
         bool r = c.always_noconv();
         assert(r == false);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_encoding.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -41,4 +41,6 @@
         int r = c.encoding();
         assert(r == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_in.pass.cpp
@@ -24,7 +24,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<char32_t> C;
@@ -356,4 +356,6 @@
         assert(np == n+1);
         assert(w == 0x56);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_length.pass.cpp
@@ -22,7 +22,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -240,4 +240,6 @@
         r = c.length(m, n, n+1, 3);
         assert(r == 1);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_max_length.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -59,4 +59,6 @@
         int r = c.max_length();
         assert(r == 7);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_out.pass.cpp
@@ -318,8 +318,10 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   TestHelper<wchar_t>::test();
   TestHelper<char32_t>::test();
   TestHelper<char16_t>::test();
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_unshift.pass.cpp
@@ -23,7 +23,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> C;
@@ -52,4 +52,6 @@
         std::codecvt_base::result r = c.unshift(m, n, n+4, np);
         assert(r == std::codecvt_base::noconv);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_utf16_always_noconv.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -41,4 +41,6 @@
         bool r = c.always_noconv();
         assert(r == false);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_utf16_encoding.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -41,4 +41,6 @@
         int r = c.encoding();
         assert(r == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_utf16_in.pass.cpp
@@ -234,10 +234,12 @@
   }
 }
 
-int main() {
+int main(int, char**) {
 #ifndef _WIN32
   TestHelper<wchar_t>::test();
 #endif
   TestHelper<char32_t>::test();
   TestHelper<char16_t>::test();
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_utf16_length.pass.cpp
@@ -22,7 +22,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -231,4 +231,6 @@
         r = c.length(m, n, n+1, 2);
         assert(r == 1);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_utf16_max_length.pass.cpp
@@ -21,7 +21,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -59,4 +59,6 @@
         int r = c.max_length();
         assert(r == 7);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_utf16_out.pass.cpp
@@ -299,10 +299,12 @@
   }
 }
 
-int main() {
+int main(int, char**) {
 #ifndef _WIN32
   TestHelper<wchar_t>::test();
 #endif
   TestHelper<char32_t>::test();
   TestHelper<char16_t>::test();
+
+  return 0;
 }
Index: test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp
===================================================================
--- test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp
+++ test/std/localization/locale.stdcvt/codecvt_utf8_utf16_unshift.pass.cpp
@@ -23,7 +23,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8_utf16<wchar_t> C;
@@ -52,4 +52,6 @@
         std::codecvt_base::result r = c.unshift(m, n, n+4, np);
         assert(r == std::codecvt_base::noconv);
     }
+
+  return 0;
 }
Index: test/std/localization/locale.syn/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locale.syn/nothing_to_do.pass.cpp
+++ test/std/localization/locale.syn/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/isalnum.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isalnum(' ', l));
@@ -27,4 +27,6 @@
     assert( std::isalnum('f', l));
     assert( std::isalnum('9', l));
     assert(!std::isalnum('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/isalpha.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isalpha(' ', l));
@@ -27,4 +27,6 @@
     assert( std::isalpha('f', l));
     assert(!std::isalpha('9', l));
     assert(!std::isalpha('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/iscntrl.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::iscntrl(' ', l));
@@ -27,4 +27,6 @@
     assert(!std::iscntrl('f', l));
     assert(!std::iscntrl('9', l));
     assert(!std::iscntrl('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/isdigit.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isdigit(' ', l));
@@ -27,4 +27,6 @@
     assert(!std::isdigit('f', l));
     assert( std::isdigit('9', l));
     assert(!std::isdigit('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/isgraph.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isgraph(' ', l));
@@ -27,4 +27,6 @@
     assert( std::isgraph('f', l));
     assert( std::isgraph('9', l));
     assert( std::isgraph('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/islower.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/islower.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/islower.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::islower(' ', l));
@@ -27,4 +27,6 @@
     assert( std::islower('f', l));
     assert(!std::islower('9', l));
     assert(!std::islower('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/isprint.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert( std::isprint(' ', l));
@@ -27,4 +27,6 @@
     assert( std::isprint('f', l));
     assert( std::isprint('9', l));
     assert( std::isprint('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/ispunct.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::ispunct(' ', l));
@@ -27,4 +27,6 @@
     assert(!std::ispunct('f', l));
     assert(!std::ispunct('9', l));
     assert( std::ispunct('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/isspace.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert( std::isspace(' ', l));
@@ -27,4 +27,6 @@
     assert(!std::isspace('f', l));
     assert(!std::isspace('9', l));
     assert(!std::isspace('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/isupper.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isupper(' ', l));
@@ -27,4 +27,6 @@
     assert(!std::isupper('f', l));
     assert(!std::isupper('9', l));
     assert(!std::isupper('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp
+++ test/std/localization/locales/locale.convenience/classification/isxdigit.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(!std::isxdigit(' ', l));
@@ -27,4 +27,6 @@
     assert( std::isxdigit('f', l));
     assert( std::isxdigit('9', l));
     assert(!std::isxdigit('+', l));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
 #if TEST_STD_VER > 11
@@ -55,4 +55,6 @@
         assert(globalMemCounter.checkOutstandingNewNotEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp
@@ -37,7 +37,7 @@
     virtual int_type overflow(int_type c = traits_type::eof()) {return base::overflow(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ofstream bs("overflow.dat");
@@ -96,4 +96,6 @@
         assert(f.get() == -1);
     }
     std::remove("overflow.dat");
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.cpp
@@ -37,7 +37,7 @@
     virtual int_type pbackfail(int_type c = traits_type::eof()) {return base::pbackfail(c);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream bs("underflow.dat");
@@ -55,4 +55,6 @@
         assert(f.sbumpc() == L'2');
         assert(f.sgetc() == L'3');
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.buffer/rdbuf.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
     {
@@ -27,4 +27,6 @@
         b.rdbuf(s.rdbuf());
         assert(b.rdbuf() == s.rdbuf());
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp
@@ -31,7 +31,7 @@
     ~test_codecvt() {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         wchar_t buf[10];
@@ -54,4 +54,6 @@
         assert(f.sgetc() == L'l');
     }
     std::remove("seekoff.dat");
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.buffer/state.pass.cpp
@@ -17,7 +17,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
     {
@@ -25,4 +25,6 @@
         std::mbstate_t s = b.state();
         ((void)s);
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.cpp
@@ -15,7 +15,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::ofstream bytestream("myfile.txt");
@@ -32,4 +32,6 @@
         assert(ws == L"Hello");
     }
     std::remove("myfile.txt");
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.cpp
@@ -37,7 +37,7 @@
     virtual int_type underflow() {return base::underflow();}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::ifstream bs("underflow.dat");
@@ -80,4 +80,6 @@
         assert(f.sbumpc() == 0x4E53);
         assert(f.sbumpc() == test_buf::traits_type::eof());
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.character/tolower.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(std::tolower(' ', l) == ' ');
@@ -27,4 +27,6 @@
     assert(std::tolower('f', l) == 'f');
     assert(std::tolower('9', l) == '9');
     assert(std::tolower('+', l) == '+');
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.character/toupper.pass.cpp
@@ -13,7 +13,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::locale l;
     assert(std::toupper(' ', l) == ' ');
@@ -27,4 +27,6 @@
     assert(std::toupper('f', l) == 'F');
     assert(std::toupper('9', l) == '9');
     assert(std::toupper('+', l) == '+');
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.string/converted.pass.cpp
@@ -61,4 +61,6 @@
   }
 }
 
-int main() { TestHelper<wchar_t>::test(); }
+int main(int, char**) { TestHelper<wchar_t>::test(); 
+  return 0;
+}
Index: test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> Codecvt;
@@ -36,4 +36,6 @@
         static_assert( std::is_constructible<Myconv, Codecvt*>::value, "");
 #endif
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt_state.pass.cpp
@@ -16,7 +16,7 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> Codecvt;
@@ -24,4 +24,6 @@
         Myconv myconv(new Codecvt, std::mbstate_t());
         assert(myconv.converted() == 0);
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_copy.pass.cpp
@@ -21,10 +21,12 @@
 #include <codecvt>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;
     static_assert(!std::is_copy_constructible<Myconv>::value, "");
     static_assert(!std::is_copy_assignable<Myconv>::value, "");
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_string.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;
@@ -70,4 +70,6 @@
         std::wstring ws = myconv.from_bytes('\xA5');
         assert(ws == L"wide error");
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.string/from_bytes.pass.cpp
@@ -68,4 +68,6 @@
   }
 }
 
-int main() { TestHelper<wchar_t>::test(); }
+int main(int, char**) { TestHelper<wchar_t>::test(); 
+  return 0;
+}
Index: test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.string/state.pass.cpp
@@ -15,11 +15,13 @@
 #include <locale>
 #include <codecvt>
 
-int main()
+int main(int, char**)
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;
     Myconv myconv;
     std::mbstate_t s = myconv.state();
     ((void)s);
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.string/to_bytes.pass.cpp
@@ -68,4 +68,6 @@
   }
 }
 
-int main() { TestHelper<wchar_t>::test(); }
+int main(int, char**) { TestHelper<wchar_t>::test(); 
+  return 0;
+}
Index: test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/conversions.string/types.pass.cpp
@@ -22,7 +22,7 @@
 #include <locale>
 #include <codecvt>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::wstring_convert<std::codecvt_utf8<wchar_t> > myconv;
@@ -31,4 +31,6 @@
         static_assert((std::is_same<myconv::state_type, std::mbstate_t>::value), "");
         static_assert((std::is_same<myconv::int_type, std::char_traits<wchar_t>::int_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp
+++ test/std/localization/locales/locale.convenience/conversions/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp
+++ test/std/localization/locales/locale.convenience/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locales/locale.global.templates/has_facet.pass.cpp
===================================================================
--- test/std/localization/locales/locale.global.templates/has_facet.pass.cpp
+++ test/std/localization/locales/locale.global.templates/has_facet.pass.cpp
@@ -21,11 +21,13 @@
 
 std::locale::id my_facet::id;
 
-int main()
+int main(int, char**)
 {
     std::locale loc;
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(!std::has_facet<my_facet>(loc));
     std::locale loc2(loc, new my_facet);
     assert(std::has_facet<my_facet>(loc2));
+
+  return 0;
 }
Index: test/std/localization/locales/locale.global.templates/use_facet.pass.cpp
===================================================================
--- test/std/localization/locales/locale.global.templates/use_facet.pass.cpp
+++ test/std/localization/locales/locale.global.templates/use_facet.pass.cpp
@@ -30,7 +30,7 @@
 
 std::locale::id my_facet::id;
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
@@ -53,4 +53,6 @@
         assert(facet_count == 1);
     }
     assert(facet_count == 0);
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.cons/assign.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.cons/assign.pass.cpp
+++ test/std/localization/locales/locale/locale.cons/assign.pass.cpp
@@ -56,7 +56,7 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -67,4 +67,6 @@
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
+++ test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp
@@ -61,7 +61,7 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -94,4 +94,6 @@
         std::locale ok("");
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.cons/copy.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.cons/copy.pass.cpp
+++ test/std/localization/locales/locale/locale.cons/copy.pass.cpp
@@ -54,7 +54,7 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_fr_FR_UTF_8);
@@ -64,4 +64,6 @@
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.cons/default.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.cons/default.pass.cpp
+++ test/std/localization/locales/locale/locale.cons/default.pass.cpp
@@ -53,7 +53,7 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     int ok;
     {
@@ -73,4 +73,6 @@
         assert(globalMemCounter.checkOutstandingNewEq(ok));
     }
     assert(globalMemCounter.checkOutstandingNewEq(ok));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
+++ test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.pass.cpp
@@ -59,7 +59,7 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -68,4 +68,6 @@
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
+++ test/std/localization/locales/locale/locale.cons/locale_facetptr.pass.cpp
@@ -65,7 +65,7 @@
 
 std::locale::id my_facet::id;
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -85,4 +85,6 @@
         assert(loc == loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
+++ test/std/localization/locales/locale/locale.cons/locale_locale_cat.pass.cpp
@@ -59,7 +59,7 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -68,4 +68,6 @@
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
+++ test/std/localization/locales/locale/locale.cons/locale_string_cat.pass.cpp
@@ -60,7 +60,7 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(LOCALE_ru_RU_UTF_8);
@@ -69,4 +69,6 @@
         check(loc2);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.cons/string.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.cons/string.pass.cpp
+++ test/std/localization/locales/locale/locale.cons/string.pass.cpp
@@ -55,7 +55,7 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc(std::string(LOCALE_ru_RU_UTF_8));
@@ -69,4 +69,6 @@
         assert(loc != loc3);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.members/combine.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.members/combine.pass.cpp
+++ test/std/localization/locales/locale/locale.members/combine.pass.cpp
@@ -63,7 +63,7 @@
 
 std::locale::id my_facet::id;
 
-int main()
+int main(int, char**)
 {
 {
     {
@@ -95,4 +95,6 @@
     assert(globalMemCounter.checkOutstandingNewEq(0));
 }
 #endif
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.members/name.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.members/name.pass.cpp
+++ test/std/localization/locales/locale/locale.members/name.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::locale loc;
@@ -27,4 +27,6 @@
         std::locale loc(LOCALE_en_US_UTF_8);
         assert(loc.name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.operators/compare.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.operators/compare.pass.cpp
+++ test/std/localization/locales/locale/locale.operators/compare.pass.cpp
@@ -15,7 +15,7 @@
 #include <locale>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::locale l;
@@ -30,4 +30,6 @@
             assert(l(s3, s2));
         }
     }
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.operators/eq.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.operators/eq.pass.cpp
+++ test/std/localization/locales/locale/locale.operators/eq.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     std::locale cloc;
     std::locale copy(cloc);
@@ -82,4 +82,6 @@
     assert(noname2 != noname1);
     assert(noname2 != nonamec);
     assert(noname2 == noname2);
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.statics/classic.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.statics/classic.pass.cpp
+++ test/std/localization/locales/locale/locale.statics/classic.pass.cpp
@@ -48,11 +48,13 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     std::locale loc = std::locale::classic();
     assert(loc.name() == "C");
     assert(loc == std::locale("C"));
     check(loc);
     check(std::locale("C"));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.statics/global.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.statics/global.pass.cpp
+++ test/std/localization/locales/locale/locale.statics/global.pass.cpp
@@ -52,7 +52,7 @@
     assert((std::has_facet<std::messages<wchar_t> >(loc)));
 }
 
-int main()
+int main(int, char**)
 {
     std::locale loc;
     assert(loc.name() == "C");
@@ -61,4 +61,6 @@
     std::locale loc2;
     check(loc2);
     assert(loc2 == std::locale(LOCALE_en_US_UTF_8));
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
+++ test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
@@ -23,7 +23,7 @@
 void test(const T &) {}
 
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::locale::category, int>::value), "");
     assert(std::locale::none == 0);
@@ -55,4 +55,6 @@
     test(std::locale::time);
     test(std::locale::messages);
     test(std::locale::all);
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
+++ test/std/localization/locales/locale/locale.types/locale.facet/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
+++ test/std/localization/locales/locale/locale.types/locale.id/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp
+++ test/std/localization/locales/locale/locale.types/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locales/locale/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locales/locale/nothing_to_do.pass.cpp
+++ test/std/localization/locales/locale/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/locales/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/locales/nothing_to_do.pass.cpp
+++ test/std/localization/locales/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/localization/localization.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/localization/localization.general/nothing_to_do.pass.cpp
+++ test/std/localization/localization.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/nothing_to_do.pass.cpp
===================================================================
--- test/std/nothing_to_do.pass.cpp
+++ test/std/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/c.math/cmath.pass.cpp
===================================================================
--- test/std/numerics/c.math/cmath.pass.cpp
+++ test/std/numerics/c.math/cmath.pass.cpp
@@ -1514,7 +1514,7 @@
     assert(std::trunc(1) == 1);
 }
 
-int main()
+int main(int, char**)
 {
     test_abs();
     test_acos();
@@ -1586,4 +1586,6 @@
     test_scalbn();
     test_tgamma();
     test_trunc();
+
+  return 0;
 }
Index: test/std/numerics/c.math/ctgmath.pass.cpp
===================================================================
--- test/std/numerics/c.math/ctgmath.pass.cpp
+++ test/std/numerics/c.math/ctgmath.pass.cpp
@@ -10,10 +10,12 @@
 
 #include <ctgmath>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> cd;
     (void)cd;
     double x = std::sin(0);
     ((void)x); // Prevent unused warning
+
+  return 0;
 }
Index: test/std/numerics/c.math/tgmath_h.pass.cpp
===================================================================
--- test/std/numerics/c.math/tgmath_h.pass.cpp
+++ test/std/numerics/c.math/tgmath_h.pass.cpp
@@ -10,6 +10,8 @@
 
 #include <tgmath.h>
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
===================================================================
--- test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
+++ test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp
@@ -57,7 +57,7 @@
 #error FE_DFL_ENV not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::fenv_t fenv;
     std::fexcept_t fex;
@@ -74,4 +74,6 @@
     static_assert((std::is_same<decltype(std::feholdexcept(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(std::fesetenv(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(std::feupdateenv(&fenv)), int>::value), "");
+
+  return 0;
 }
Index: test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -10,8 +10,10 @@
 
 #include <ccomplex>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> d;
     (void)d;
+
+  return 0;
 }
Index: test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp
===================================================================
--- test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp
+++ test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp
@@ -26,7 +26,7 @@
 UDT<int> it;
 UDT<unsigned long> uit;
 
-int main()
+int main(int, char**)
 {
     {
         std::real(ft); // expected-error {{no matching function}}
@@ -70,4 +70,6 @@
         std::proj(it); // expected-error {{no matching function}}
         std::proj(uit); // expected-error {{no matching function}}
     }
+
+  return 0;
 }
Index: test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
===================================================================
--- test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
+++ test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
@@ -43,7 +43,7 @@
     test<T>(10);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -51,4 +51,6 @@
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/cmplx.over/conj.pass.cpp
===================================================================
--- test/std/numerics/complex.number/cmplx.over/conj.pass.cpp
+++ test/std/numerics/complex.number/cmplx.over/conj.pass.cpp
@@ -54,7 +54,7 @@
     test<T>(10);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -62,4 +62,6 @@
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
===================================================================
--- test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
+++ test/std/numerics/complex.number/cmplx.over/imag.pass.cpp
@@ -56,7 +56,7 @@
     test<T, 10>();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -64,4 +64,6 @@
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/cmplx.over/norm.pass.cpp
===================================================================
--- test/std/numerics/complex.number/cmplx.over/norm.pass.cpp
+++ test/std/numerics/complex.number/cmplx.over/norm.pass.cpp
@@ -43,7 +43,7 @@
     test<T>(10);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -51,4 +51,6 @@
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
===================================================================
--- test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
+++ test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
@@ -78,7 +78,7 @@
     test(std::complex<T>(3, 4), std::complex<U>(5, 6));
 }
 
-int main()
+int main(int, char**)
 {
     test<int, float>();
     test<int, double>();
@@ -100,4 +100,6 @@
 
     test<long double, float>();
     test<long double, double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/cmplx.over/proj.pass.cpp
===================================================================
--- test/std/numerics/complex.number/cmplx.over/proj.pass.cpp
+++ test/std/numerics/complex.number/cmplx.over/proj.pass.cpp
@@ -54,7 +54,7 @@
     test<T>(10);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -62,4 +62,6 @@
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/cmplx.over/real.pass.cpp
===================================================================
--- test/std/numerics/complex.number/cmplx.over/real.pass.cpp
+++ test/std/numerics/complex.number/cmplx.over/real.pass.cpp
@@ -56,7 +56,7 @@
     test<T, 10>();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
@@ -64,4 +64,6 @@
     test<int>();
     test<unsigned>();
     test<long long>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.literals/literals.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.literals/literals.pass.cpp
+++ test/std/numerics/complex.number/complex.literals/literals.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::complex_literals;
 
@@ -47,4 +47,6 @@
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
===================================================================
--- test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
+++ test/std/numerics/complex.number/complex.literals/literals1.fail.cpp
@@ -13,7 +13,9 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::complex<float> foo  = 1.0if;  // should fail w/conversion operator not found
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
+++ test/std/numerics/complex.number/complex.literals/literals1.pass.cpp
@@ -13,7 +13,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals;
 
@@ -37,4 +37,6 @@
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
+++ test/std/numerics/complex.number/complex.literals/literals2.pass.cpp
@@ -13,7 +13,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std;
 
@@ -37,4 +37,6 @@
     auto c2 = 3if;
     assert ( c1 == c2 );
     }
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp
@@ -31,7 +31,7 @@
     assert(c.imag() == -4.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float, float>();
     test<float, double>();
@@ -44,4 +44,6 @@
     test<long double, float>();
     test<long double, double>();
     test<long double, long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp
@@ -28,9 +28,11 @@
     assert(c.imag() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
@@ -44,9 +44,11 @@
 
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp
@@ -35,9 +35,11 @@
     assert(c.imag() == 4);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp
@@ -43,9 +43,11 @@
     assert(c3.imag() == -6);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp
@@ -31,9 +31,11 @@
     assert(c.imag() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp
@@ -43,9 +43,11 @@
     assert(c3.imag() == 6);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp
@@ -31,9 +31,11 @@
     assert(c.imag() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp
@@ -43,9 +43,11 @@
     assert(c3.imag() ==   3.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp
@@ -35,9 +35,11 @@
     assert(c.imag() == 3);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.members/construct.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.members/construct.pass.cpp
+++ test/std/numerics/complex.number/complex.members/construct.pass.cpp
@@ -63,9 +63,11 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.members/real_imag.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.members/real_imag.pass.cpp
+++ test/std/numerics/complex.number/complex.members/real_imag.pass.cpp
@@ -56,10 +56,12 @@
     test_constexpr<T> ();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_constexpr<int> ();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -149,10 +149,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp
@@ -32,9 +32,11 @@
     test(lhs, rhs, x);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
@@ -52,10 +52,12 @@
     test_constexpr<T> ();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //    test_constexpr<int> ();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
@@ -73,10 +73,12 @@
     test_constexpr<T> ();
     }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //     test_constexpr<int> ();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp
@@ -40,9 +40,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp
@@ -40,9 +40,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
@@ -54,10 +54,12 @@
     test_constexpr<T> ();
     }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //   test_constexpr<int> ();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
@@ -73,10 +73,12 @@
     test_constexpr<T> ();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //     test_constexpr<int> ();
-    }
+    
+  return 0;
+}
Index: test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp
@@ -40,9 +40,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp
@@ -40,9 +40,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp
@@ -151,10 +151,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp
@@ -32,9 +32,11 @@
     test(lhs, rhs, x);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
@@ -32,9 +32,11 @@
     test(lhs, rhs, x);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
@@ -73,10 +73,12 @@
     test_constexpr<T> ();
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //     test_constexpr<int>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp
@@ -40,9 +40,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
@@ -73,10 +73,12 @@
     test_constexpr<T> ();
     }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 //     test_constexpr<int>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp
@@ -40,9 +40,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp
@@ -32,9 +32,11 @@
     test(lhs, rhs, x);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/stream_input.pass.cpp
@@ -16,7 +16,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream is("5");
@@ -95,4 +95,6 @@
         assert(c == std::complex<double>(-5.5, -6.5));
         assert(!is.eof());
     }
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/stream_output.pass.cpp
@@ -16,10 +16,12 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::complex<double> c(1, 2);
     std::ostringstream os;
     os << c;
     assert(os.str() == "(1,2)");
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp
@@ -27,9 +27,11 @@
     assert(c.imag() == -2.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp
+++ test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp
@@ -27,9 +27,11 @@
     assert(c.imag() == 2.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
+++ test/std/numerics/complex.number/complex.special/double_float_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<float> cd(2.5, 3.5);
@@ -35,4 +35,6 @@
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
+++ test/std/numerics/complex.number/complex.special/double_float_implicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<float> cd(2.5, 3.5);
@@ -35,4 +35,6 @@
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
+++ test/std/numerics/complex.number/complex.special/double_long_double_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<long double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp
+++ test/std/numerics/complex.number/complex.special/double_long_double_implicit.fail.cpp
@@ -17,10 +17,12 @@
 #include <complex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::complex<long double> cd(2.5, 3.5);
     std::complex<double> cf = cd;
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
+++ test/std/numerics/complex.number/complex.special/float_double_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp
+++ test/std/numerics/complex.number/complex.special/float_double_implicit.fail.cpp
@@ -17,10 +17,12 @@
 #include <complex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::complex<double> cd(2.5, 3.5);
     std::complex<float> cf = cd;
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
+++ test/std/numerics/complex.number/complex.special/float_long_double_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<long double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp
+++ test/std/numerics/complex.number/complex.special/float_long_double_implicit.fail.cpp
@@ -17,10 +17,12 @@
 #include <complex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::complex<long double> cd(2.5, 3.5);
     std::complex<float> cf = cd;
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
+++ test/std/numerics/complex.number/complex.special/long_double_double_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
+++ test/std/numerics/complex.number/complex.special/long_double_double_implicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<double> cd(2.5, 3.5);
@@ -35,4 +35,6 @@
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
+++ test/std/numerics/complex.number/complex.special/long_double_float_explicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<float> cd(2.5, 3.5);
@@ -35,4 +35,6 @@
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
+++ test/std/numerics/complex.number/complex.special/long_double_float_implicit.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::complex<float> cd(2.5, 3.5);
@@ -35,4 +35,6 @@
     static_assert(cf.imag() == cd.imag(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp
+++ test/std/numerics/complex.number/complex.synopsis/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -129,10 +129,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -140,10 +140,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -108,10 +108,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -117,10 +117,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -57,10 +57,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -121,10 +121,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -56,10 +56,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -106,10 +106,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
@@ -104,10 +104,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
@@ -121,10 +121,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
@@ -55,10 +55,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
@@ -60,10 +60,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
@@ -58,10 +58,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
@@ -58,10 +58,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -57,10 +57,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -107,10 +107,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -99,10 +99,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -58,10 +58,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -89,10 +89,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -53,10 +53,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -125,10 +125,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp
+++ test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp
@@ -32,9 +32,11 @@
     test(std::complex<T>(-1, -2), std::complex<T>(-1, 2));
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp
+++ test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp
@@ -23,9 +23,11 @@
     assert(imag(z) == 2.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
+++ test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp
@@ -53,10 +53,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -102,10 +102,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
+++ test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp
@@ -61,10 +61,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex.value.ops/real.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex.value.ops/real.pass.cpp
+++ test/std/numerics/complex.number/complex.value.ops/real.pass.cpp
@@ -23,9 +23,11 @@
     assert(real(z) == 1.5);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/complex/types.pass.cpp
===================================================================
--- test/std/numerics/complex.number/complex/types.pass.cpp
+++ test/std/numerics/complex.number/complex/types.pass.cpp
@@ -27,9 +27,11 @@
     static_assert((std::is_same<typename C::value_type, T>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/complex.number/layout.pass.cpp
===================================================================
--- test/std/numerics/complex.number/layout.pass.cpp
+++ test/std/numerics/complex.number/layout.pass.cpp
@@ -27,9 +27,11 @@
     assert(a[1] == z.imag());
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/numerics/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/nothing_to_do.pass.cpp
+++ test/std/numerics/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp
===================================================================
--- test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp
+++ test/std/numerics/numarray/class.gslice/gslice.access/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp
===================================================================
--- test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp
+++ test/std/numerics/numarray/class.gslice/gslice.cons/default.pass.cpp
@@ -15,10 +15,12 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::gslice gs;
     assert(gs.start() == 0);
     assert(gs.size().size() == 0);
     assert(gs.stride().size() == 0);
+
+  return 0;
 }
Index: test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp
===================================================================
--- test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp
+++ test/std/numerics/numarray/class.gslice/gslice.cons/start_size_stride.pass.cpp
@@ -16,7 +16,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::size_t a1[] = {1, 2, 3};
     std::size_t a2[] = {4, 5, 6};
@@ -34,4 +34,6 @@
     assert(r[0] == 4);
     assert(r[1] == 5);
     assert(r[2] == 6);
+
+  return 0;
 }
Index: test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp
+++ test/std/numerics/numarray/class.gslice/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp
===================================================================
--- test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp
+++ test/std/numerics/numarray/class.slice/cons.slice/default.pass.cpp
@@ -15,10 +15,12 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::slice s;
     assert(s.start() == 0);
     assert(s.size() == 0);
     assert(s.stride() == 0);
+
+  return 0;
 }
Index: test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp
===================================================================
--- test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp
+++ test/std/numerics/numarray/class.slice/cons.slice/start_size_stride.pass.cpp
@@ -15,10 +15,12 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::slice s(1, 3, 2);
     assert(s.start() == 1);
     assert(s.size() == 3);
     assert(s.stride() == 2);
+
+  return 0;
 }
Index: test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp
+++ test/std/numerics/numarray/class.slice/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp
===================================================================
--- test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp
+++ test/std/numerics/numarray/class.slice/slice.access/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/default.fail.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/default.fail.cpp
+++ test/std/numerics/numarray/template.gslice.array/default.fail.cpp
@@ -15,7 +15,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::gslice_array<int> gs;
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.assign/gslice_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -77,4 +77,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.assign/valarray.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/and.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/divide.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/modulo.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/multiply.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/or.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_left.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/shift_right.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.comp.assign/xor.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/gslice.array.fill/assign_value.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -70,4 +70,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.gslice.array/types.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.gslice.array/types.pass.cpp
+++ test/std/numerics/numarray/template.gslice.array/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::gslice_array<int>::value_type, int>::value), "");
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/default.fail.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/default.fail.cpp
+++ test/std/numerics/numarray/template.indirect.array/default.fail.cpp
@@ -15,7 +15,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::indirect_array<int> ia;
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.assign/indirect_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -76,4 +76,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.assign/valarray.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/and.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/divide.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/modulo.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/multiply.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/or.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_left.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/shift_right.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.comp.assign/xor.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/indirect.array.fill/assign_value.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -70,4 +70,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.indirect.array/types.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.indirect.array/types.pass.cpp
+++ test/std/numerics/numarray/template.indirect.array/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::indirect_array<int>::value_type, int>::value), "");
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/default.fail.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/default.fail.cpp
+++ test/std/numerics/numarray/template.mask.array/default.fail.cpp
@@ -15,7 +15,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::mask_array<int> s;
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.assign/mask_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
@@ -62,4 +62,6 @@
     std::mask_array<int> const & r = (m1 = m2);
     assert(&r == &m1);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.assign/valarray.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/and.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/divide.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/modulo.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/multiply.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/or.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_left.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/shift_right.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.comp.assign/xor.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -45,4 +45,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/mask.array.fill/assign_value.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -41,4 +41,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.mask.array/types.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.mask.array/types.pass.cpp
+++ test/std/numerics/numarray/template.mask.array/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::mask_array<int>::value_type, int>::value), "");
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/default.fail.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/default.fail.cpp
+++ test/std/numerics/numarray/template.slice.array/default.fail.cpp
@@ -15,7 +15,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::slice_array<int> s;
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.assign/slice_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
@@ -50,4 +50,6 @@
     std::slice_array<int> const & s3 = (s1 = s2);
     assert(&s1 == &s3);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.assign/valarray.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@
     assert(v1[13] == -5);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/addition.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@
     assert(v1[13] ==  8);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/and.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@
     assert(v1[13] ==  5);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/divide.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@
     assert(v1[13] == -2);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/modulo.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@
     assert(v1[13] ==  3);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/multiply.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@
     assert(v1[13] == -65);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/or.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@
     assert(v1[13] == 13);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_left.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@
     assert(v1[13] == 416);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/shift_right.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@
     assert(v1[13] ==  0);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/subtraction.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@
     assert(v1[13] == 18);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.comp.assign/xor.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {1, 2, 3, 4, 5};
@@ -39,4 +39,6 @@
     assert(v1[13] ==  8);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/slice.arr.fill/assign_value.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     std::valarray<int> v1(a1, sizeof(a1)/sizeof(a1[0]));
@@ -37,4 +37,6 @@
     assert(v1[13] == 20);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.slice.array/types.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.slice.array/types.pass.cpp
+++ test/std/numerics/numarray/template.slice.array/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::slice_array<int>::value_type, int>::value), "");
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/types.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/types.pass.cpp
+++ test/std/numerics/numarray/template.valarray/types.pass.cpp
@@ -18,8 +18,10 @@
 #include <valarray>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::valarray<int>::value_type, int>::value), "");
     static_assert((std::is_same<std::valarray<double>::value_type, double>::value), "");
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
             assert(v[i] == static_cast<int>(i));
         }
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -27,4 +27,6 @@
             assert(v[i] == a[i]);
         }
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
@@ -31,7 +31,7 @@
     return lhs.x_ == rhs.x_;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -82,4 +82,6 @@
             assert(v2[i] == v[i]);
         assert(!S::default_ctor_called);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.assign/gslice_array_assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -54,4 +54,6 @@
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.assign/indirect_array_assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -54,4 +54,6 @@
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
@@ -33,7 +33,7 @@
     return lhs.x_ == rhs.x_;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -80,4 +80,6 @@
             assert(v2[i] == a[i]);
         assert(!S::default_ctor_called);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.assign/mask_array_assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -31,4 +31,6 @@
     assert(v2[ 2] ==  4);
     assert(v2[ 3] ==  7);
     assert(v2[ 4] == 11);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -60,4 +60,6 @@
                 assert(v2[i][j] == a[i][j]);
         }
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.assign/slice_array_assign.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     std::valarray<int> v1(a, sizeof(a)/sizeof(a[0]));
@@ -27,4 +27,6 @@
     assert(v[2] == 7);
     assert(v[3] == 10);
     assert(v[4] == 13);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.assign/value_assign.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -28,4 +28,6 @@
         for (std::size_t i = 0; i < v.size(); ++i)
             assert(v[i] == 7);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/and_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/and_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/divide_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/divide_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/minus_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/minus_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v2[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/modulo_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/or_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/or_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/plus_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/plus_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/shift_left_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/shift_right_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/times_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/times_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/xor_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -33,4 +33,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cassign/xor_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -30,4 +30,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == v2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -52,4 +52,6 @@
                 assert(v2[i][j] == v[i][j]);
         }
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp
@@ -22,7 +22,7 @@
 
 bool S::ctor_called = false;
 
-int main()
+int main(int, char**)
 {
     {
         std::valarray<int> v;
@@ -45,4 +45,6 @@
         assert(v.size() == 0);
         assert(!S::ctor_called);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/gslice_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -53,4 +53,6 @@
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/indirect_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -53,4 +53,6 @@
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -37,4 +37,6 @@
         for (unsigned i = 0; i < N; ++i)
             assert(v[i] == a[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/mask_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -30,4 +30,6 @@
     assert(v2[ 2] ==  4);
     assert(v2[ 3] ==  7);
     assert(v2[ 4] == 11);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -58,4 +58,6 @@
                 assert(v2[i][j] == a[i][j]);
         }
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -49,4 +49,6 @@
                 assert(v[i][j] == a[i][j]);
         }
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp
@@ -24,7 +24,7 @@
 
 size_t S::cnt_dtor = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::valarray<int> v(100);
@@ -51,4 +51,6 @@
             assert(v[i].x == 1);
     }
     assert(S::cnt_dtor == 100);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/slice_array.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     std::valarray<int> v1(a, sizeof(a)/sizeof(a[0]));
@@ -26,4 +26,6 @@
     assert(v[2] == 7);
     assert(v[3] == 10);
     assert(v[4] == 13);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.cons/value_size.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::valarray<int> v(5, 100);
@@ -35,4 +35,6 @@
         for (int i = 0; i < 100; ++i)
             assert(v[i].size() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/apply_cref.pass.cpp
@@ -19,7 +19,7 @@
 
 T f(const T& t) {return t + 5;}
 
-int main()
+int main(int, char**)
 {
     {
         T a1[] = {1, 2, 3, 4,  5,  6,  7,  8,  9, 10};
@@ -47,4 +47,6 @@
         for (unsigned i = 0; i < N1; ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/apply_value.pass.cpp
@@ -19,7 +19,7 @@
 
 T f(T t) {return t + 5;}
 
-int main()
+int main(int, char**)
 {
     {
         T a1[] = {1, 2, 3, 4,  5,  6,  7,  8,  9, 10};
@@ -47,4 +47,6 @@
         for (unsigned i = 0; i < N1; ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/cshift.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -123,4 +123,6 @@
         for (unsigned i = 0; i < N1; ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/max.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -36,4 +36,6 @@
         std::valarray<T> v1(a1, N1);
         assert((2*v1).max() == 8.0);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/min.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -36,4 +36,6 @@
         std::valarray<T> v1(a1, N1);
         assert((2*v1).min() == -6.0);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/resize.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -38,4 +38,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v1[i] == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/shift.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -123,4 +123,6 @@
         for (unsigned i = 0; i < N1; ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/size.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -37,4 +37,6 @@
         std::valarray<T> v1;
         assert(v1.size() == N1);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/sum.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -24,4 +24,6 @@
         std::valarray<T> v1(a1, N1);
         assert(v1.sum() == 16.5);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.members/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -82,4 +82,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == v1_save[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.sub/gslice_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -73,4 +73,6 @@
     assert(v1[38] == 38);
     assert(v1[39] == 39);
     assert(v1[40] == 40);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.sub/gslice_non_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -53,4 +53,6 @@
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -53,4 +53,6 @@
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.sub/indirect_array_non_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
@@ -54,4 +54,6 @@
     assert(v[21] == 34);
     assert(v[22] == 35);
     assert(v[23] == 36);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.sub/slice_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     std::valarray<int> v1(a1, sizeof(a1)/sizeof(a1[0]));
@@ -26,4 +26,6 @@
     assert(v2[2] ==  7);
     assert(v2[3] == 10);
     assert(v2[4] == 13);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.sub/slice_non_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     int a2[] = {-1, -2, -3, -4, -5};
@@ -39,4 +39,6 @@
     assert(v1[13] == -5);
     assert(v1[14] == 14);
     assert(v1[15] == 15);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -30,4 +30,6 @@
     assert(v2[ 2] ==  4);
     assert(v2[ 3] ==  7);
     assert(v2[ 4] == 11);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.sub/valarray_bool_non_const.pass.cpp
@@ -15,7 +15,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
@@ -31,4 +31,6 @@
     assert(v2[ 2] ==  4);
     assert(v2[ 3] ==  7);
     assert(v2[ 4] == 11);
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -52,4 +52,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == ~(2*v[i]));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -62,4 +62,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == -2*v[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.unary/not.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -38,4 +38,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == !(2 * v[i]));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
===================================================================
--- test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
+++ test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -62,4 +62,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == +2*v[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/and_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/divide_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/minus_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/modulo_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/or_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/plus_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_left_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/shift_right_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/times_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -32,4 +32,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_valarray_value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.binary/xor_value_valarray.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == a2[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -34,4 +34,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@
         for (std::size_t i = 0; i < v1.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -42,4 +42,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.special/swap.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -84,4 +84,6 @@
         for (std::size_t i = 0; i < v2.size(); ++i)
             assert(v2[i] == v1_save[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/abs_valarray.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -31,4 +31,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(v3[i] == a3[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/acos_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/asin_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -50,4 +50,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_valarray_value.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan2_value_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/atan_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cos_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/cosh_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/exp_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log10_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/log_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -50,4 +50,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_valarray_value.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/pow_value_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sin_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sinh_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/sqrt_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tan_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
+++ test/std/numerics/numarray/valarray.nonmembers/valarray.transcend/tanh_valarray.pass.cpp
@@ -31,7 +31,7 @@
     return a == o.str();
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef double T;
@@ -48,4 +48,6 @@
         for (std::size_t i = 0; i < v3.size(); ++i)
             assert(is_about(v3[i], a3[i], 10));
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.range/begin_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.range/begin_const.pass.cpp
+++ test/std/numerics/numarray/valarray.range/begin_const.pass.cpp
@@ -17,7 +17,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -26,4 +26,6 @@
         const std::valarray<T> v(a, N);
         assert(v[0] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp
+++ test/std/numerics/numarray/valarray.range/begin_non_const.pass.cpp
@@ -17,7 +17,7 @@
 #include <valarray>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -27,4 +27,6 @@
         *begin(v) = 10;
         assert(v[0] == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.range/end_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.range/end_const.pass.cpp
+++ test/std/numerics/numarray/valarray.range/end_const.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -28,4 +28,6 @@
         assert(v[v.size()-1] == 5);
         assert(static_cast<std::size_t>(end(v) - begin(v)) == v.size());
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp
+++ test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -29,4 +29,6 @@
         assert(v[v.size()-1] == 10);
         assert(static_cast<std::size_t>(end(v) - begin(v)) == v.size());
     }
+
+  return 0;
 }
Index: test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp
+++ test/std/numerics/numarray/valarray.syn/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
+++ test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
@@ -42,11 +42,13 @@
     test(Iter(ia), Iter(ia+sa), 10, 31);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*> >();
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
+++ test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
@@ -44,11 +44,13 @@
     test(Iter(ia), Iter(ia+sa), 10, 7200);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*> >();
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
+++ test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
@@ -75,7 +75,7 @@
 
 #endif
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -112,4 +112,6 @@
     Y y[3] = {Y(1), Y(2), Y(3)};
     std::adjacent_difference(x, x+3, y);
 #endif
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
+++ test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
@@ -78,7 +78,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -115,4 +115,6 @@
     Y y[3] = {Y(1), Y(2), Y(3)};
     std::adjacent_difference(x, x+3, y, std::minus<X>());
 #endif
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
+++ test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
@@ -85,7 +85,7 @@
 
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -96,4 +96,6 @@
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
+++ test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
@@ -59,7 +59,7 @@
         }
 }
 
-int main()
+int main(int, char**)
 {
 //  All the iterator categories
     test<input_iterator        <const int*> >();
@@ -85,4 +85,6 @@
         assert(res[i] == j);
     }
     }
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
+++ test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
@@ -90,7 +90,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -101,4 +101,6 @@
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
+++ test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
@@ -97,7 +97,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
 
     basic_tests();
@@ -110,4 +110,6 @@
 //     test<const int*>();
 //     test<      int*>();
 
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
+++ test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
@@ -113,7 +113,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
 
     basic_tests();
@@ -126,4 +126,6 @@
     test<const int*>();
     test<      int*>();
 
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
+++ test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
@@ -47,7 +47,7 @@
     test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 66);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -78,4 +78,6 @@
     test<const int*, bidirectional_iterator<const int*> >();
     test<const int*, random_access_iterator<const int*> >();
     test<const int*, const int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
+++ test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
@@ -50,7 +50,7 @@
     test(Iter1(a), Iter1(a+sa), Iter2(b), 10, 1176490);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, input_iterator<const int*> >();
     test<input_iterator<const int*>, forward_iterator<const int*> >();
@@ -81,4 +81,6 @@
     test<const int*, bidirectional_iterator<const int*> >();
     test<const int*, random_access_iterator<const int*> >();
     test<const int*, const int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
+++ test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
@@ -28,10 +28,12 @@
         assert(ia[i] == ir[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<forward_iterator<int*> >();
     test<bidirectional_iterator<int*> >();
     test<random_access_iterator<int*> >();
     test<int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd(false, 4);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd(2, true);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd<volatile bool, int>(false, 4);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd<int, const bool>(2, true);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd(2.0, 4);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::gcd(4, 6.0);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
@@ -91,7 +91,7 @@
     return accumulate;
 }
 
-int main()
+int main(int, char**)
 {
     auto non_cce = std::rand(); // a value that can't possibly be constexpr
 
@@ -141,4 +141,6 @@
     static_assert(std::is_same_v<decltype(res), std::int64_t>, "");
     assert(res == 2);
     }
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm(false, 4);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm(2, true);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm<volatile bool, int>(false, 4);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm<int, const bool>(2, true);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm(2.0, 4);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.fail.cpp
@@ -18,7 +18,9 @@
 #include <numeric>
 
 
-int main()
+int main(int, char**)
 {
     std::lcm(4, 6.0);
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
+++ test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
@@ -90,7 +90,7 @@
     return accumulate;
 }
 
-int main()
+int main(int, char**)
 {
     auto non_cce = std::rand(); // a value that can't possibly be constexpr
 
@@ -141,4 +141,6 @@
     static_assert(std::is_same_v<decltype(res1), std::int64_t>, "");
     assert(res1 == 1324997410816LL);
     }
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
+++ test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
@@ -35,7 +35,7 @@
         assert(ib[i] == ir[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -66,4 +66,6 @@
     test<const int*, bidirectional_iterator<int*> >();
     test<const int*, random_access_iterator<int*> >();
     test<const int*, int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
+++ test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
@@ -37,7 +37,7 @@
         assert(ib[i] == ir[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
@@ -68,4 +68,6 @@
     test<const int*, bidirectional_iterator<int*> >();
     test<const int*, random_access_iterator<int*> >();
     test<const int*, int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
+++ test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
@@ -46,7 +46,7 @@
     static_assert( std::is_same_v<T, decltype(std::reduce(p, p))> );
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char>();
     test_return_type<int>();
@@ -59,4 +59,6 @@
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
+++ test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
@@ -48,7 +48,7 @@
     static_assert( std::is_same_v<Init, decltype(std::reduce(p, p, Init{}))> );
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -63,4 +63,6 @@
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
+++ test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
@@ -48,7 +48,7 @@
     static_assert( std::is_same_v<Init, decltype(std::reduce(p, p, Init{}, std::plus<>()))>, "" );
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -70,4 +70,6 @@
     unsigned res = std::reduce(v.begin(), v.end(), 1U, std::multiplies<>());
     assert(res == 40320);       // 8! will not fit into a char
     }
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
+++ test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
@@ -139,7 +139,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -150,4 +150,6 @@
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
+++ test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
@@ -113,7 +113,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -124,4 +124,6 @@
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
+++ test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
@@ -139,7 +139,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     basic_tests();
 
@@ -150,4 +150,6 @@
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
+++ test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
@@ -91,7 +91,7 @@
         [](const MoveOnly& target) { return MoveOnly{target.get() * 10}; }).get());
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -117,4 +117,6 @@
     }
 
     test_move_only_types();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
+++ test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
@@ -65,7 +65,7 @@
         std::transform_reduce(std::begin(ia), std::end(ia), std::begin(ib), MoveOnly{0}).get());
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -103,4 +103,6 @@
     test<      int*,       unsigned int *>();
 
     test_move_only_types();
+
+  return 0;
 }
Index: test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
+++ test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
@@ -69,7 +69,7 @@
         [](const MoveOnly& lhs, const MoveOnly& rhs) { return MoveOnly{lhs.get() * rhs.get()}; }).get());
 }
 
-int main()
+int main(int, char**)
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
@@ -107,4 +107,6 @@
     test<      int*,       unsigned int *>();
 
     test_move_only_types();
+
+  return 0;
 }
Index: test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp
+++ test/std/numerics/numeric.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/numerics.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/numerics.general/nothing_to_do.pass.cpp
+++ test/std/numerics/numerics.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.adapt/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
@@ -48,8 +48,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
@@ -46,8 +46,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::ranlux24_base Engine;
@@ -25,4 +25,6 @@
         Adaptor a(e);
         assert(a.base() == e);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::ranlux24_base Engine;
@@ -26,4 +26,6 @@
         Adaptor a(std::move(e0));
         assert(a.base() == e);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.pass.cpp
@@ -43,8 +43,10 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.pass.cpp
@@ -47,8 +47,10 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/default.pass.cpp
@@ -34,8 +34,10 @@
     assert(e1() == 23459059301164ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
@@ -44,8 +44,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/eval.pass.cpp
@@ -34,8 +34,10 @@
     assert(e() == 276846226770426ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.pass.cpp
@@ -55,8 +55,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/result_type.pass.cpp
@@ -34,8 +34,10 @@
         std::uint_fast64_t>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_result_type.pass.cpp
@@ -42,8 +42,10 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/seed_sseq.pass.cpp
@@ -40,8 +40,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
@@ -64,8 +64,10 @@
     where(E::used_block);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
@@ -48,8 +48,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
@@ -46,8 +46,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::mt19937 Engine;
@@ -25,4 +25,6 @@
         Adaptor a(e);
         assert(a.base() == e);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::mt19937 Engine;
@@ -26,4 +26,6 @@
         Adaptor a(std::move(e0));
         assert(a.base() == e);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
@@ -43,8 +43,10 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
@@ -47,8 +47,10 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
@@ -34,8 +34,10 @@
     assert(e1() == 18223106896348967647ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
@@ -44,8 +44,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
@@ -129,7 +129,7 @@
     assert(e() == 16470362623952407241ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -139,4 +139,6 @@
     test6();
     test7();
     test8();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
@@ -55,8 +55,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/result_type.pass.cpp
@@ -77,8 +77,10 @@
         unsigned long long>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
@@ -42,8 +42,10 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
@@ -40,8 +40,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
@@ -51,8 +51,10 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
@@ -32,7 +32,9 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
@@ -31,7 +31,9 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::minstd_rand0 Engine;
@@ -29,4 +29,6 @@
 
         assert(a.base() == e);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::minstd_rand0 Engine;
@@ -30,4 +30,6 @@
 
         assert(a.base() == e);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.pass.cpp
@@ -69,7 +69,9 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.pass.cpp
@@ -72,7 +72,9 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/default.pass.cpp
@@ -25,7 +25,9 @@
     assert(e1() == 152607844u);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
@@ -30,7 +30,9 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/eval.pass.cpp
@@ -86,9 +86,11 @@
     assert(e() == 500);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.pass.cpp
@@ -41,7 +41,9 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/result_type.pass.cpp
@@ -77,8 +77,10 @@
         unsigned long long>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_result_type.pass.cpp
@@ -29,7 +29,9 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/seed_sseq.pass.cpp
@@ -28,7 +28,9 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
+++ test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
@@ -44,7 +44,9 @@
     where(E::table_size);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.device/ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.device/ctor.pass.cpp
+++ test/std/numerics/rand/rand.device/ctor.pass.cpp
@@ -62,7 +62,7 @@
 }
 
 
-int main() {
+int main(int, char**) {
   {
     std::random_device r;
   }
@@ -99,4 +99,6 @@
     std::random_device r;
   }
 #endif // !defined(_WIN32)
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.device/entropy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.device/entropy.pass.cpp
+++ test/std/numerics/rand/rand.device/entropy.pass.cpp
@@ -15,9 +15,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::random_device r;
     double e = r.entropy();
     ((void)e); // Prevent unused warning
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.device/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.device/eval.pass.cpp
+++ test/std/numerics/rand/rand.device/eval.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::random_device r;
@@ -45,4 +45,6 @@
     {
     }
 #endif
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.dis/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/assign.pass.cpp
@@ -26,7 +26,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/copy.pass.cpp
@@ -24,7 +24,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -32,4 +32,6 @@
         D d(0.75);
         assert(d.p() == 0.75);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_param.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -24,4 +24,6 @@
         D d(p);
         assert(d.p() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eq.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -32,4 +32,6 @@
         D d2(.25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp
@@ -26,7 +26,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -100,4 +100,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp
@@ -26,7 +26,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -104,4 +104,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/get_param.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -24,4 +24,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.pass.cpp
@@ -24,7 +24,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -36,4 +36,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/max.pass.cpp
@@ -15,11 +15,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
         D d(.25);
         assert(d.max() == true);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/min.pass.cpp
@@ -15,11 +15,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
         D d(.5);
         assert(d.min() == false);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_assign.pass.cpp
@@ -16,7 +16,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -26,4 +26,6 @@
         p = p0;
         assert(p.p() == .7);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -25,4 +25,6 @@
         param_type p = p0;
         assert(p.p() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_ctor.pass.cpp
@@ -16,7 +16,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -30,4 +30,6 @@
         param_type p(0.25);
         assert(p.p() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_eq.pass.cpp
@@ -16,7 +16,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -32,4 +32,6 @@
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/param_types.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -23,4 +23,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/set_param.pass.cpp
@@ -15,7 +15,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
@@ -25,4 +25,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/types.pass.cpp
@@ -15,11 +15,13 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, bool>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -36,4 +36,6 @@
         assert(d.t() == 3);
         assert(d.p() == 0.75);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.t() == 5);
         assert(d.p() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -39,4 +39,6 @@
         D d2(4, .25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
@@ -506,7 +506,7 @@
 //    assert(kurtosis == x_kurtosis);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -519,4 +519,6 @@
     test9();
     test10();
     test11();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
@@ -28,7 +28,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -156,4 +156,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.04);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.3);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
         D d(4, .25);
         assert(d.max() == 4);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
         D d(4, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.t() == 6);
         assert(p.p() == .7);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -27,4 +27,6 @@
         assert(p.t() == 10);
         assert(p.p() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -40,4 +40,6 @@
         assert(p.t() == 10);
         assert(p.p() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(3, 0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
@@ -28,4 +28,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -28,4 +28,6 @@
         D d(0.75);
         assert(d.p() == 0.75);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.p() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(.25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
@@ -286,7 +286,7 @@
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -294,4 +294,6 @@
     test4();
     test5();
     test6();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
@@ -28,7 +28,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -156,4 +156,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
         D d(.25);
         assert(d.max() == std::numeric_limits<int>::max());
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
         D d(.5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -27,4 +27,6 @@
         p = p0;
         assert(p.p() == .7);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -26,4 +26,6 @@
         param_type p = p0;
         assert(p.p() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -31,4 +31,6 @@
         param_type p(0.25);
         assert(p.p() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
@@ -28,4 +28,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -36,4 +36,6 @@
         assert(d.k() == 3);
         assert(d.p() == 0.75);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.k() == 5);
         assert(d.p() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -39,4 +39,6 @@
         D d2(4, .25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
@@ -284,7 +284,7 @@
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -292,4 +292,6 @@
     test4();
     test5();
     test6();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
@@ -28,7 +28,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -156,4 +156,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
         D d(4, .25);
         assert(d.max() == std::numeric_limits<int>::max());
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
         D d(4, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.k() == 6);
         assert(p.p() == .7);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -27,4 +27,6 @@
         assert(p.k() == 10);
         assert(p.p() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -40,4 +40,6 @@
         assert(p.k() == 10);
         assert(p.p() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(3, 0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
@@ -28,4 +28,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -36,4 +36,6 @@
         assert(d.a() == 14.5);
         assert(d.b() == 5.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.a() == 0.25);
         assert(d.b() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
@@ -26,7 +26,7 @@
     return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -73,4 +73,6 @@
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
@@ -26,7 +26,7 @@
     return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -79,4 +79,6 @@
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
         D d(.5, .5);
         assert(d.min() == -INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.a() == .75);
         assert(p.b() == 6);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -27,4 +27,6 @@
         assert(p.a() == 10);
         assert(p.b() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -40,4 +40,6 @@
         assert(p.a() == 10);
         assert(p.b() == 5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -28,4 +28,6 @@
         D d(14.5);
         assert(d.n() == 14.5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.n() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -148,4 +148,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -154,4 +154,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
         D d(.5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -27,4 +27,6 @@
         p = p0;
         assert(p.n() == .75);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -26,4 +26,6 @@
         param_type p = p0;
         assert(p.n() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -31,4 +31,6 @@
         param_type p(10);
         assert(p.n() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -36,4 +36,6 @@
         assert(d.m() == 14.5);
         assert(d.n() == 5.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.m() == 0.25);
         assert(d.n() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval.pass.cpp
@@ -45,7 +45,7 @@
     return I(m * x / (m*x + n), static_cast<unsigned>(m/2), static_cast<unsigned>(n/2));
 }
 
-int main()
+int main(int, char**)
 {
     // Purposefully only testing even integral values of m and n (for now)
     {
@@ -99,4 +99,6 @@
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], d.m(), d.n()) - double(i)/N) < .01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/eval_param.pass.cpp
@@ -45,7 +45,7 @@
     return I(m * x / (m*x + n), static_cast<unsigned>(m/2), static_cast<unsigned>(n/2));
 }
 
-int main()
+int main(int, char**)
 {
     // Purposefully only testing even integral values of m and n (for now)
     {
@@ -105,4 +105,6 @@
         for (int i = 0; i < N; ++i)
             assert(std::abs(f(u[i], p.m(), p.n()) - double(i)/N) < .01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
         D d(.5, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.m() == .75);
         assert(p.n() == 6);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -27,4 +27,6 @@
         assert(p.m() == 10);
         assert(p.n() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -40,4 +40,6 @@
         assert(p.m() == 10);
         assert(p.n() == 5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -36,4 +36,6 @@
         assert(d.m() == 14.5);
         assert(d.s() == 5.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.m() == 0.25);
         assert(d.s() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
@@ -248,11 +248,13 @@
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
     test5();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
@@ -258,11 +258,13 @@
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
     test5();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
         D d(.5, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.m() == .75);
         assert(p.s() == 6);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -27,4 +27,6 @@
         assert(p.m() == 10);
         assert(p.s() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -40,4 +40,6 @@
         assert(p.m() == 10);
         assert(p.s() == 5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -36,4 +36,6 @@
         assert(d.mean() == 14.5);
         assert(d.stddev() == 5.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.mean() == 0.25);
         assert(d.stddev() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -66,4 +66,6 @@
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs(kurtosis - x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -68,4 +68,6 @@
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs(kurtosis - x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
         D d(.5, .5);
         assert(d.min() == -INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.mean() == .75);
         assert(p.stddev() == 6);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -27,4 +27,6 @@
         assert(p.mean() == 10);
         assert(p.stddev() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -40,4 +40,6 @@
         assert(p.mean() == 10);
         assert(p.stddev() == 5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -28,4 +28,6 @@
         D d(14.5);
         assert(d.n() == 14.5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.n() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
@@ -28,7 +28,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -135,4 +135,6 @@
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
@@ -28,7 +28,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -141,4 +141,6 @@
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
         D d(.5);
         assert(d.min() == -INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -27,4 +27,6 @@
         p = p0;
         assert(p.n() == .75);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -26,4 +26,6 @@
         param_type p = p0;
         assert(p.n() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -31,4 +31,6 @@
         param_type p(10);
         assert(p.n() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -28,4 +28,6 @@
         D d(3.5);
         assert(d.lambda() == 3.5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.lambda() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(.25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -148,4 +148,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -72,4 +72,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == std::numeric_limits<D::result_type>::infinity());
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
         D d(.5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -27,4 +27,6 @@
         p = p0;
         assert(p.lambda() == .7);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -26,4 +26,6 @@
         param_type p = p0;
         assert(p.lambda() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -31,4 +31,6 @@
         param_type p(10);
         assert(p.lambda() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -36,4 +36,6 @@
         assert(d.a() == 14.5);
         assert(d.b() == 5.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.a() == 0.25);
         assert(d.b() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
@@ -192,10 +192,12 @@
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
@@ -200,10 +200,12 @@
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
         D d(.5, .5);
         assert(d.min() == -INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.a() == .75);
         assert(p.b() == 6);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -27,4 +27,6 @@
         assert(p.a() == 10);
         assert(p.b() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -40,4 +40,6 @@
         assert(p.a() == 10);
         assert(p.b() == 5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -36,4 +36,6 @@
         assert(d.alpha() == 14.5);
         assert(d.beta() == 5.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.alpha() == 0.25);
         assert(d.beta() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
@@ -28,7 +28,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -147,4 +147,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
@@ -28,7 +28,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -153,4 +153,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
         D d(.5, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.alpha() == .75);
         assert(p.beta() == 6);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -27,4 +27,6 @@
         assert(p.alpha() == 10);
         assert(p.beta() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -40,4 +40,6 @@
         assert(p.alpha() == 10);
         assert(p.beta() == 5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -28,4 +28,6 @@
         D d(3.5);
         assert(d.mean() == 3.5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.mean() == 0.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(.25);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
@@ -28,7 +28,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -147,4 +147,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
@@ -28,7 +28,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -153,4 +153,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == std::numeric_limits<int>::max());
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
         D d(.5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -27,4 +27,6 @@
         p = p0;
         assert(p.mean() == .7);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -26,4 +26,6 @@
         param_type p = p0;
         assert(p.mean() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -31,4 +31,6 @@
         param_type p(10);
         assert(p.mean() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, unsigned long long>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -36,4 +36,6 @@
         assert(d.a() == 14.5);
         assert(d.b() == 5.25);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.a() == 0.25);
         assert(d.b() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(2.5, 4.5);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -160,4 +160,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -166,4 +166,6 @@
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -24,4 +24,6 @@
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
         D d(.5, .5);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.a() == .75);
         assert(p.b() == 6);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -27,4 +27,6 @@
         assert(p.a() == 10);
         assert(p.b() == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -40,4 +40,6 @@
         assert(p.a() == 10);
         assert(p.b() == 5);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -33,4 +33,6 @@
         param_type p2(0.5, .5);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/types.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
@@ -30,4 +30,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/assign.pass.cpp
@@ -28,7 +28,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/copy.pass.cpp
@@ -26,7 +26,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -25,4 +25,6 @@
         assert(p.size() == 1);
         assert(p[0] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp
@@ -23,7 +23,7 @@
     return x+1;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -56,4 +56,6 @@
         assert(p[1] == .21875);
         assert(p[2] == .28125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -77,4 +77,6 @@
         assert(p[1] == 0);
         assert(p[2] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp
@@ -17,7 +17,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -83,4 +83,6 @@
         assert(p[1] == 0);
         assert(p[2] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -29,4 +29,6 @@
         assert(p[0] == 0.25);
         assert(p[1] == 0.75);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -41,4 +41,6 @@
         D d2;
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
@@ -19,7 +19,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -275,4 +275,6 @@
             else
                 assert(u[i] == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/eval_param.pass.cpp
@@ -19,7 +19,7 @@
 #include <vector>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -41,4 +41,6 @@
         for (int i = 0; i <= 2; ++i)
             assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -26,4 +26,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -38,4 +38,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -30,4 +30,6 @@
         D d(p0, p0+4);
         assert(d.max() == 3);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/min.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -24,4 +24,6 @@
         D d(p0, p0+3);
         assert(d.min() == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -28,4 +28,6 @@
         p = p0;
         assert(p == p0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -27,4 +27,6 @@
         param_type p = p0;
         assert(p == p0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -28,4 +28,6 @@
         assert(p.size() == 1);
         assert(p[0] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp
@@ -23,7 +23,7 @@
     return x+1;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -60,4 +60,6 @@
         assert(p[1] == .21875);
         assert(p[2] == .28125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -84,4 +84,6 @@
         assert(p[1] == 0);
         assert(p[2] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp
@@ -17,7 +17,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -90,4 +90,6 @@
         assert(p[1] == 0);
         assert(p[2] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -35,4 +35,6 @@
         param_type p2;
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -27,4 +27,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
@@ -28,4 +28,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/assign.pass.cpp
@@ -29,7 +29,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/copy.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_default.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -31,4 +31,6 @@
         assert(dn.size() == 1);
         assert(dn[0] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_func.pass.cpp
@@ -23,7 +23,7 @@
     return 2*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -60,4 +60,6 @@
         assert(dn[0] == 0.1);
         assert(dn[1] == 0.15);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_init_func.pass.cpp
@@ -26,7 +26,7 @@
     return x*2;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -74,4 +74,6 @@
         assert(dn[0] == 0.203125);
         assert(dn[1] == 0.1484375);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_iterator.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -92,4 +92,6 @@
         assert(dn[1] == .3125);
         assert(dn[2] == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -37,4 +37,6 @@
         assert(dn[1] == .3125);
         assert(dn[2] == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -43,4 +43,6 @@
         D d2;
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
@@ -723,7 +723,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -736,4 +736,6 @@
     test9();
     test10();
     test11();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
@@ -31,7 +31,7 @@
     return x*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -95,4 +95,6 @@
             }
         }
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -28,4 +28,6 @@
         D d(pa);
         assert(d.param() == pa);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -40,4 +40,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -26,4 +26,6 @@
         D d(b, b+Np+1, p);
         assert(d.max() == 17);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/min.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -26,4 +26,6 @@
         D d(b, b+Np+1, p);
         assert(d.min() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -30,4 +30,6 @@
         p1 = p0;
         assert(p1 == p0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -29,4 +29,6 @@
         P p1 = p0;
         assert(p1 == p0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_default.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -30,4 +30,6 @@
         assert(dn.size() == 1);
         assert(dn[0] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_func.pass.cpp
@@ -23,7 +23,7 @@
     return 2*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -63,4 +63,6 @@
         assert(dn[0] == 0.1);
         assert(dn[1] == 0.15);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_init_func.pass.cpp
@@ -23,7 +23,7 @@
     return x*2;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -75,4 +75,6 @@
         assert(dn[0] == 0.203125);
         assert(dn[1] == 0.1484375);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_ctor_iterator.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -96,4 +96,6 @@
         assert(dn[1] == .3125);
         assert(dn[2] == .125);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -37,4 +37,6 @@
         P p2(b, b+4, p);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -28,4 +28,6 @@
         d.param(pa);
         assert(d.param() == pa);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
@@ -28,4 +28,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/assign.pass.cpp
@@ -29,7 +29,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/copy.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_default.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -32,4 +32,6 @@
         assert(dn[0] == 1);
         assert(dn[1] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_func.pass.cpp
@@ -25,7 +25,7 @@
     return 2*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -65,4 +65,6 @@
         assert(dn[1] == 0.125);
         assert(dn[2] == 0.175);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_init_func.pass.cpp
@@ -26,7 +26,7 @@
     return x*2;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -78,4 +78,6 @@
         assert(dn[1] == 0.125);
         assert(dn[2] == 0.175);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_iterator.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -97,4 +97,6 @@
         assert(dn[2] == 1/4.5);
         assert(dn[3] == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -38,4 +38,6 @@
         assert(dn[2] == 12.5/256.25);
         assert(dn[3] == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -43,4 +43,6 @@
         D d2;
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
@@ -354,7 +354,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
@@ -362,4 +362,6 @@
     test4();
     test5();
     test6();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
@@ -37,7 +37,7 @@
     return a + m*(sqr(x) - sqr(b))/2 + c*(x-b);
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -90,4 +90,6 @@
             assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
         }
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -28,4 +28,6 @@
         D d(pa);
         assert(d.param() == pa);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -40,4 +40,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/max.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -26,4 +26,6 @@
         D d(b, b+Np, p);
         assert(d.max() == 17);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/min.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -26,4 +26,6 @@
         D d(b, b+Np, p);
         assert(d.min() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -30,4 +30,6 @@
         p1 = p0;
         assert(p1 == p0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -29,4 +29,6 @@
         P p1 = p0;
         assert(p1 == p0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_default.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -31,4 +31,6 @@
         assert(dn[0] == 1);
         assert(dn[1] == 1);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_func.pass.cpp
@@ -23,7 +23,7 @@
     return 2*x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -66,4 +66,6 @@
         assert(dn[1] == 0.125);
         assert(dn[2] == 0.175);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_init_func.pass.cpp
@@ -23,7 +23,7 @@
     return x*2;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -79,4 +79,6 @@
         assert(dn[1] == 0.125);
         assert(dn[2] == 0.175);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_ctor_iterator.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -101,4 +101,6 @@
         assert(dn[2] == 1/4.5);
         assert(dn[3] == 0);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -37,4 +37,6 @@
         P p2(b, b+4, p);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -28,4 +28,6 @@
         d.param(pa);
         assert(d.param() == pa);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
@@ -28,4 +28,6 @@
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp
@@ -17,7 +17,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -37,4 +37,6 @@
         assert(d.a() == -6);
         assert(d.b() == 106);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.a() == 3);
         assert(d.b() == 8);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(3, 9);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -452,4 +452,6 @@
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp
@@ -27,7 +27,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -72,4 +72,6 @@
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
         D d(3, 8);
         assert(d.max() == 8);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
         D d(3, 8);
         assert(d.min() == 3);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -28,4 +28,6 @@
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -27,4 +27,6 @@
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -40,4 +40,6 @@
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -33,4 +33,6 @@
         param_type p2(6, 10);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/types.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<long> D;
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, long>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/assign.pass.cpp
@@ -27,7 +27,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/copy.pass.cpp
@@ -25,7 +25,9 @@
     assert(d1 == d2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp
@@ -17,7 +17,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -37,4 +37,6 @@
         assert(d.a() == -6);
         assert(d.b() == 106);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -26,4 +26,6 @@
         assert(d.a() == 3.5);
         assert(d.b() == 8);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eq.pass.cpp
@@ -19,7 +19,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -33,4 +33,6 @@
         D d2(3, 8.1);
         assert(d1 != d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
@@ -29,7 +29,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -471,4 +471,6 @@
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp
@@ -27,7 +27,7 @@
     return x * x;
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -71,4 +71,6 @@
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/get_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -25,4 +25,6 @@
         D d(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.pass.cpp
@@ -25,7 +25,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -37,4 +37,6 @@
         is >> d2;
         assert(d1 == d2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/max.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
         D d(3, 8);
         assert(d.max() == 8);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/min.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
         D d(3, 8);
         assert(d.min() == 3);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -28,4 +28,6 @@
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_copy.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -27,4 +27,6 @@
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -40,4 +40,6 @@
         assert(p.a() == 5);
         assert(p.b() == 10);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_eq.pass.cpp
@@ -17,7 +17,7 @@
 #include <limits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -33,4 +33,6 @@
         param_type p2(6, 10);
         assert(p1 != p2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/param_types.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
@@ -24,4 +24,6 @@
         typedef param_type::distribution_type distribution_type;
         static_assert((std::is_same<D, distribution_type>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/set_param.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<> D;
@@ -26,4 +26,6 @@
         d.param(p);
         assert(d.param() == p);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp
+++ test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/types.pass.cpp
@@ -16,11 +16,13 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::uniform_real_distribution<float> D;
         typedef D::result_type result_type;
         static_assert((std::is_same<result_type, float>::value), "");
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.eng/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
@@ -48,10 +48,12 @@
     test1<T, M-1, M-1, M>();
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
@@ -48,10 +48,12 @@
     test1<T, M-1, M-1, M>();
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
@@ -129,7 +129,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1<unsigned short>();
     test1<unsigned int>();
@@ -150,4 +150,6 @@
     test4<unsigned int>();
     test4<unsigned long>();
     test4<unsigned long long>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_sseq.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         unsigned a[] = {3, 5, 7};
@@ -25,4 +25,6 @@
         std::linear_congruential_engine<unsigned, 5, 7, 11> e2(4);
         assert(e1 == e2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
@@ -46,10 +46,12 @@
     test1<T, M-1, M-1, M>();
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
@@ -56,7 +56,7 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     rand0<unsigned int>();
     rand0<unsigned long>();
@@ -69,4 +69,6 @@
     other<unsigned int>();
     other<unsigned long>();
     other<unsigned long long>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/eval.pass.cpp
@@ -70,7 +70,7 @@
     assert(e() == 217250280);
 }
 
-int main()
+int main(int, char**)
 {
     randu<unsigned int>();
     randu<unsigned long>();
@@ -83,4 +83,6 @@
     Haldir<unsigned int>();
     Haldir<unsigned long>();
     Haldir<unsigned long long>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/io.pass.cpp
@@ -27,7 +27,7 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::linear_congruential_engine<unsigned, 48271, 0, 2147483647> E;
@@ -40,4 +40,6 @@
         is >> e2;
         assert(e1 == e2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
@@ -27,10 +27,12 @@
         T>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_result_type.pass.cpp
@@ -30,10 +30,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1<unsigned short>();
     test1<unsigned int>();
     test1<unsigned long>();
     test1<unsigned long long>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/seed_sseq.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         unsigned a[] = {3, 5, 7};
@@ -35,4 +35,6 @@
         E e2(sseq);
         assert(e1 == e2);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
@@ -85,10 +85,12 @@
     test1<T, M-1, M-1, M>();
 }
 
-int main()
+int main(int, char**)
 {
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
@@ -50,8 +50,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
@@ -48,8 +48,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
@@ -237,8 +237,10 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
@@ -301,8 +301,10 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp
@@ -71,10 +71,12 @@
   assert(e() == X0);
 }
 
-int main() {
+int main(int, char**) {
   // Test for k == 1: word_size <= 32.
   test<unsigned short, 3u>();
 
   // Test for k == 2: (32 < word_size <= 64).
   test<unsigned long long, 33u>();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
@@ -37,8 +37,10 @@
     assert(e1() == 14514284786278117030ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
@@ -47,8 +47,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
@@ -37,8 +37,10 @@
     assert(e() == 13109570281517897720ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
@@ -61,8 +61,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
@@ -36,8 +36,10 @@
         std::uint_fast64_t>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
@@ -44,8 +44,10 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
@@ -42,8 +42,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
@@ -126,8 +126,10 @@
     where(E::default_seed);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
@@ -48,8 +48,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
@@ -46,8 +46,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
@@ -43,8 +43,10 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.pass.cpp
@@ -47,8 +47,10 @@
     assert(os.str() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/default.pass.cpp
@@ -34,8 +34,10 @@
     assert(e1() == 23459059301164ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
@@ -44,8 +44,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/eval.pass.cpp
@@ -34,8 +34,10 @@
     assert(e() == 276846226770426ull);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/io.pass.cpp
@@ -55,8 +55,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/result_type.pass.cpp
@@ -34,8 +34,10 @@
         std::uint_fast64_t>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/seed_result_type.pass.cpp
@@ -42,8 +42,10 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/seed_sseq.pass.cpp
@@ -40,8 +40,10 @@
     assert(e1 == e2);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
+++ test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
@@ -74,8 +74,10 @@
     where(E::default_seed);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp
+++ test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp
@@ -15,9 +15,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::default_random_engine e;
     e.discard(9999);
     LIBCPP_ASSERT(e() == 399268537u);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/knuth_b.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/knuth_b.pass.cpp
+++ test/std/numerics/rand/rand.predef/knuth_b.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::knuth_b e;
     e.discard(9999);
     assert(e() == 1112339016u);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp
+++ test/std/numerics/rand/rand.predef/minstd_rand.pass.cpp
@@ -14,9 +14,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::minstd_rand e;
     e.discard(9999);
     assert(e() == 399268537u);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp
+++ test/std/numerics/rand/rand.predef/minstd_rand0.pass.cpp
@@ -14,9 +14,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::minstd_rand0 e;
     e.discard(9999);
     assert(e() == 1043618065u);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/mt19937.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/mt19937.pass.cpp
+++ test/std/numerics/rand/rand.predef/mt19937.pass.cpp
@@ -18,9 +18,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::mt19937 e;
     e.discard(9999);
     assert(e() == 4123659995u);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp
+++ test/std/numerics/rand/rand.predef/mt19937_64.pass.cpp
@@ -18,9 +18,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::mt19937_64 e;
     e.discard(9999);
     assert(e() == 9981545732273789042ull);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/ranlux24.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/ranlux24.pass.cpp
+++ test/std/numerics/rand/rand.predef/ranlux24.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ranlux24 e;
     e.discard(9999);
     assert(e() == 9901578u);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp
+++ test/std/numerics/rand/rand.predef/ranlux24_base.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ranlux24_base e;
     e.discard(9999);
     assert(e() == 7937952u);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/ranlux48.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/ranlux48.pass.cpp
+++ test/std/numerics/rand/rand.predef/ranlux48.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ranlux48 e;
     e.discard(9999);
     assert(e() == 249142670248501ull);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp
+++ test/std/numerics/rand/rand.predef/ranlux48_base.pass.cpp
@@ -13,9 +13,11 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ranlux48_base e;
     e.discard(9999);
     assert(e() == 61839128582725ull);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.req/rand.req.adapt/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.req/rand.req.dst/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.req/rand.req.eng/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.req/rand.req.genl/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.req/rand.req.seedseq/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.req/rand.req.urng/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp
+++ test/std/numerics/rand/rand.util/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
+++ test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "truncate_fp.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::minstd_rand0 E;
@@ -98,4 +98,6 @@
             (282475249 - E::min()) * (E::max() - E::min() + F(1))) /
             ((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))));
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp
===================================================================
--- test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp
+++ test/std/numerics/rand/rand.util/rand.util.seedseq/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <random>
 
-int main()
+int main(int, char**)
 {
     std::seed_seq s0;
     std::seed_seq s;
     s = s0;
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp
===================================================================
--- test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp
+++ test/std/numerics/rand/rand.util/rand.util.seedseq/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <random>
 
-int main()
+int main(int, char**)
 {
     std::seed_seq s0;
     std::seed_seq s(s0);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp
+++ test/std/numerics/rand/rand.util/rand.util.seedseq/default.pass.cpp
@@ -15,8 +15,10 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::seed_seq s;
     assert(s.size() == 0);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp
+++ test/std/numerics/rand/rand.util/rand.util.seedseq/generate.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         // These numbers generated from a slightly altered version of dSFMT
@@ -801,4 +801,6 @@
         for (int i = 0; i < n; ++i)
             assert(a[i] == b[i]);
     }
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp
+++ test/std/numerics/rand/rand.util/rand.util.seedseq/initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::seed_seq s= {5, 4, 3, 2, 1};
     assert(s.size() == 5);
@@ -29,4 +29,6 @@
     assert(b[2] == 3);
     assert(b[3] == 2);
     assert(b[4] == 1);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp
+++ test/std/numerics/rand/rand.util/rand.util.seedseq/iterator.pass.cpp
@@ -16,7 +16,7 @@
 #include <random>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     unsigned a[5] = {5, 4, 3, 2, 1};
     std::seed_seq s(a, a+5);
@@ -28,4 +28,6 @@
     assert(b[2] == 3);
     assert(b[3] == 2);
     assert(b[4] == 1);
+
+  return 0;
 }
Index: test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp
===================================================================
--- test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp
+++ test/std/numerics/rand/rand.util/rand.util.seedseq/types.pass.cpp
@@ -17,7 +17,9 @@
 #include <random>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::seed_seq::result_type, std::uint_least32_t>::value), "");
+
+  return 0;
 }
Index: test/std/re/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/nothing_to_do.pass.cpp
+++ test/std/re/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.alg/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.alg/nothing_to_do.pass.cpp
+++ test/std/re/re.alg/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.match/awk.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/awk.pass.cpp
+++ test/std/re/re.alg/re.alg.match/awk.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1391,4 +1391,5 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+    return 0;
 }
Index: test/std/re/re.alg/re.alg.match/basic.fail.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/basic.fail.cpp
+++ test/std/re/re.alg/re.alg.match/basic.fail.cpp
@@ -25,11 +25,13 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::smatch m;
         std::regex re{"*"};
         std::regex_match(std::string("abcde"), m, re);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.match/basic.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/basic.pass.cpp
+++ test/std/re/re.alg/re.alg.match/basic.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1367,4 +1367,6 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.match/ecma.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/ecma.pass.cpp
+++ test/std/re/re.alg/re.alg.match/ecma.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1391,4 +1391,6 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.match/egrep.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/egrep.pass.cpp
+++ test/std/re/re.alg/re.alg.match/egrep.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -78,4 +78,6 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == "tourna");
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.match/exponential.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/exponential.pass.cpp
+++ test/std/re/re.alg/re.alg.match/exponential.pass.cpp
@@ -23,7 +23,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
Index: test/std/re/re.alg/re.alg.match/extended.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/extended.pass.cpp
+++ test/std/re/re.alg/re.alg.match/extended.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1363,4 +1363,6 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.match/grep.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/grep.pass.cpp
+++ test/std/re/re.alg/re.alg.match/grep.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -46,4 +46,6 @@
                 std::regex_constants::grep)));
         assert(m.size() == 0);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
+++ test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
@@ -15,7 +15,7 @@
 #include <regex>
 
 
-int main() {
+int main(int, char**) {
     assert(std::regex_match("X", std::regex("[X]")));
     assert(std::regex_match("X", std::regex("[XY]")));
     assert(!std::regex_match("X", std::regex("[^X]")));
@@ -40,4 +40,6 @@
     assert(!std::regex_match("_", std::regex("[\\W]")));
     assert(std::regex_match("X", std::regex("[^\\W]")));
     assert(std::regex_match("_", std::regex("[^\\W]")));
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
+++ test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex re("^(?=(.))a$");
@@ -95,4 +95,6 @@
         assert(m[3] == "a");
         assert(m[4] == "");
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
+++ test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp
@@ -62,10 +62,12 @@
     assert((std::regex_match(target, smatch, regex)));
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
     test3();
     test4();
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
+++ test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     try {
         std::regex re("a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa");
@@ -35,4 +35,5 @@
     } catch (const std::regex_error &e) {
       assert(e.code() == std::regex_constants::error_complexity);
     }
+    return 0;
 }
Index: test/std/re/re.alg/re.alg.replace/test1.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.replace/test1.pass.cpp
+++ test/std/re/re.alg/re.alg.replace/test1.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -104,4 +104,6 @@
         assert(r.base() == buf+12);
         assert(buf == std::string("123-555-1234"));
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.replace/test2.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.replace/test2.pass.cpp
+++ test/std/re/re.alg/re.alg.replace/test2.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -104,4 +104,6 @@
         assert(r.base() == buf+12);
         assert(buf == std::string("123-555-1234"));
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.replace/test3.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.replace/test3.pass.cpp
+++ test/std/re/re.alg/re.alg.replace/test3.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -70,4 +70,6 @@
                                            std::regex_constants::format_no_copy);
         assert(r == "123-555-1234");
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.replace/test4.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.replace/test4.pass.cpp
+++ test/std/re/re.alg/re.alg.replace/test4.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -69,4 +69,6 @@
                                            std::regex_constants::format_no_copy);
         assert(r == "123-555-1234");
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.replace/test5.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.replace/test5.pass.cpp
+++ test/std/re/re.alg/re.alg.replace/test5.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -70,4 +70,6 @@
                                            std::regex_constants::format_no_copy);
         assert(r == "123-555-1234");
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.replace/test6.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.replace/test6.pass.cpp
+++ test/std/re/re.alg/re.alg.replace/test6.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -70,4 +70,6 @@
                                            std::regex_constants::format_no_copy);
         assert(r == "123-555-1234");
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/awk.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/awk.pass.cpp
+++ test/std/re/re.alg/re.alg.search/awk.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1574,4 +1574,6 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/backup.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/backup.pass.cpp
+++ test/std/re/re.alg/re.alg.search/backup.pass.cpp
@@ -21,7 +21,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     // This regex_iterator uses regex_search(__wrap_iter<_Iter> __first, ...)
     // Test for https://bugs.llvm.org/show_bug.cgi?id=16240 fixed in r185273.
@@ -60,4 +60,6 @@
         ++it;
         assert(it == end);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/basic.fail.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/basic.fail.cpp
+++ test/std/re/re.alg/re.alg.search/basic.fail.cpp
@@ -25,11 +25,13 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::smatch m;
         std::regex re{"*"};
         std::regex_search(std::string("abcde"), m, re);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/basic.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/basic.pass.cpp
+++ test/std/re/re.alg/re.alg.search/basic.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1547,4 +1547,6 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/ecma.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/ecma.pass.cpp
+++ test/std/re/re.alg/re.alg.search/ecma.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1589,4 +1589,6 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/egrep.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/egrep.pass.cpp
+++ test/std/re/re.alg/re.alg.search/egrep.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -87,4 +87,6 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == "tourna");
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/exponential.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/exponential.pass.cpp
+++ test/std/re/re.alg/re.alg.search/exponential.pass.cpp
@@ -23,7 +23,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
Index: test/std/re/re.alg/re.alg.search/extended.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/extended.pass.cpp
+++ test/std/re/re.alg/re.alg.search/extended.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -1543,4 +1543,6 @@
         assert(m.position(0) == 0);
         assert(m.str(0) == s);
     }
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/grep.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/grep.pass.cpp
+++ test/std/re/re.alg/re.alg.search/grep.pass.cpp
@@ -50,7 +50,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::cmatch m;
@@ -85,4 +85,6 @@
         assert(m.str(0) == "");
     }
     fuzz_tests();
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
+++ test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
@@ -20,7 +20,7 @@
 
 
 // PR34310
-int main()
+int main(int, char**)
 {
   assert(std::regex_search("HelloWorld", std::regex("[^\\W]")));
   assert(std::regex_search("_", std::regex("[^\\W]")));
Index: test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
+++ test/std/re/re.alg/re.alg.search/lookahead.pass.cpp
@@ -21,8 +21,10 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(!std::regex_search("ab", std::regex("(?=^)b")));
     assert(!std::regex_search("ab", std::regex("a(?=^)b")));
+
+  return 0;
 }
Index: test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
===================================================================
--- test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
+++ test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     // Iterating over /^a/ should yield one instance at the beginning
     // of the text.
@@ -35,4 +35,6 @@
 
     ++it;
     assert(it == end);
+
+  return 0;
 }
Index: test/std/re/re.alg/re.except/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.alg/re.except/nothing_to_do.pass.cpp
+++ test/std/re/re.alg/re.except/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.badexp/regex_error.pass.cpp
===================================================================
--- test/std/re/re.badexp/regex_error.pass.cpp
+++ test/std/re/re.badexp/regex_error.pass.cpp
@@ -21,7 +21,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_error e(std::regex_constants::error_collate);
@@ -93,4 +93,6 @@
         assert(e.what() == std::string("There was insufficient memory to determine whether the regular "
                "expression could match the specified character sequence."));
     }
+
+  return 0;
 }
Index: test/std/re/re.const/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.const/nothing_to_do.pass.cpp
+++ test/std/re/re.const/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.const/re.err/error_type.pass.cpp
===================================================================
--- test/std/re/re.const/re.err/error_type.pass.cpp
+++ test/std/re/re.const/re.err/error_type.pass.cpp
@@ -35,7 +35,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::regex_constants::error_collate != 0);
     assert(std::regex_constants::error_ctype != 0);
@@ -140,4 +140,6 @@
     assert(std::regex_constants::error_badrepeat != std::regex_constants::error_stack);
 
     assert(std::regex_constants::error_complexity != std::regex_constants::error_stack);
+
+  return 0;
 }
Index: test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
===================================================================
--- test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
+++ test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
@@ -35,7 +35,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::regex_constants::match_default == 0);
     assert(std::regex_constants::match_not_bol != 0);
@@ -125,4 +125,6 @@
     e1 &= e2;
     e1 |= e2;
     e1 ^= e2;
+
+  return 0;
 }
Index: test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
===================================================================
--- test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
+++ test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string target = "foo";
@@ -47,4 +47,6 @@
     assert( std::regex_search(target, re));
     assert( std::regex_search(target, re, std::regex_constants::match_not_bol));
     }
+
+  return 0;
 }
Index: test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
===================================================================
--- test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
+++ test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string target = "foo";
@@ -47,4 +47,6 @@
     assert( std::regex_search(target, re));
     assert( std::regex_search(target, re, std::regex_constants::match_not_eol));
     }
+
+  return 0;
 }
Index: test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
===================================================================
--- test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
+++ test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
@@ -15,7 +15,7 @@
 #include <cassert>
 #include <regex>
 
-int main()
+int main(int, char**)
 {
   // When match_not_null is on, the regex engine should reject empty matches and
   // move on to try other solutions.
Index: test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
===================================================================
--- test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
+++ test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
@@ -32,7 +32,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::regex_constants::icase != 0);
     assert(std::regex_constants::nosubs != 0);
@@ -111,4 +111,6 @@
     e1 &= e2;
     e1 |= e2;
     e1 ^= e2;
+
+  return 0;
 }
Index: test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
+++ test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
+++ test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
+++ test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
+++ test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
+++ test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
+++ test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
+++ test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.def/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.def/nothing_to_do.pass.cpp
+++ test/std/re/re.def/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.general/nothing_to_do.pass.cpp
+++ test/std/re/re.general/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.grammar/excessive_brace_count.pass.cpp
===================================================================
--- test/std/re/re.grammar/excessive_brace_count.pass.cpp
+++ test/std/re/re.grammar/excessive_brace_count.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::basic, std::regex::grep}) {
     try {
Index: test/std/re/re.grammar/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.grammar/nothing_to_do.pass.cpp
+++ test/std/re/re.grammar/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.iter/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.iter/nothing_to_do.pass.cpp
+++ test/std/re/re.iter/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
===================================================================
--- test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
+++ test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.fail.cpp
@@ -24,7 +24,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
@@ -32,4 +32,6 @@
             std::begin(phone_book), std::end(phone_book),
             std::regex("\\d{3}-\\d{4}"));
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
===================================================================
--- test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
+++ test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -41,4 +41,6 @@
         ++i;
         assert(i == std::cregex_iterator());
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
===================================================================
--- test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
+++ test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
@@ -25,8 +25,10 @@
     assert(i1 == I());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
Index: test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
===================================================================
--- test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
+++ test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
@@ -13,6 +13,8 @@
 // bool operator==(const regex_iterator& right) const;
 // bool operator!=(const regex_iterator& right) const;
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
===================================================================
--- test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
+++ test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -39,4 +39,6 @@
         ++i;
         assert(i == std::cregex_iterator());
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
===================================================================
--- test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
+++ test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -112,4 +112,6 @@
         ++i;
         assert(i == e);
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.regiter/types.pass.cpp
===================================================================
--- test/std/re/re.iter/re.regiter/types.pass.cpp
+++ test/std/re/re.iter/re.regiter/types.pass.cpp
@@ -38,8 +38,10 @@
     static_assert((std::is_same<typename I::iterator_category, std::forward_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.fail.cpp
@@ -26,7 +26,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -35,4 +35,6 @@
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
                                      std::regex("\\d{3}-\\d{4}"), indices);
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
@@ -21,7 +21,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -61,4 +61,6 @@
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
@@ -25,8 +25,10 @@
     assert(i1 == I());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.fail.cpp
@@ -24,7 +24,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -32,4 +32,6 @@
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
                                       std::regex("\\d{3}-\\d{4}"), {-1, 0, 1});
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
@@ -22,7 +22,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -61,4 +61,6 @@
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.fail.cpp
@@ -23,7 +23,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -31,4 +31,6 @@
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
                                      std::regex("\\d{3}-\\d{4}"), -1);
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -72,4 +72,6 @@
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.fail.cpp
@@ -25,7 +25,7 @@
 #error
 #endif
 
-int main()
+int main(int, char**)
 {
     {
          std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -36,4 +36,6 @@
         std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
                                      std::regex("\\d{3}-\\d{4}"), v);
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-(\\d{4})");
@@ -125,4 +125,6 @@
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -33,4 +33,6 @@
         assert(!(i2 == i));
         assert(i2 != i);
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -69,4 +69,6 @@
         ++i;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
+++ test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex phone_numbers("\\d{3}-\\d{4}");
@@ -132,4 +132,6 @@
         i++;
         assert(i == std::cregex_token_iterator());
     }
+
+  return 0;
 }
Index: test/std/re/re.iter/re.tokiter/types.pass.cpp
===================================================================
--- test/std/re/re.iter/re.tokiter/types.pass.cpp
+++ test/std/re/re.iter/re.tokiter/types.pass.cpp
@@ -38,8 +38,10 @@
     static_assert((std::is_same<typename I::iterator_category, std::forward_iterator_tag>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'});
@@ -30,4 +30,6 @@
     r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/assign.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/assign.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/assign.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2;
@@ -34,4 +34,6 @@
     assert(r2.mark_count() == 2);
     assert(std::regex_search("ab", r2));
 #endif
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     typedef input_iterator<std::string::const_iterator> I;
     typedef forward_iterator<std::string::const_iterator> F;
@@ -43,4 +43,6 @@
     r2.assign(F(s4.begin()), F(s4.end()), std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2.assign("(a([bc]))");
@@ -26,4 +26,6 @@
     r2.assign("(a([bc]))", std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
@@ -16,10 +16,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2.assign("(a([bc]))", 9, std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2.assign(std::string("(a([bc]))"));
@@ -28,4 +28,6 @@
     r2.assign(std::string("(a([bc]))"), std::regex::extended);
     assert(r2.flags() == std::regex::extended);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/copy.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/copy.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/copy.pass.cpp
@@ -16,11 +16,13 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2;
     r2 = r1;
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/il.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/il.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/il.pass.cpp
@@ -18,10 +18,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2 = {'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'};
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
@@ -16,10 +16,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2 = "(a([bc]))";
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.assign/string.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.assign/string.pass.cpp
+++ test/std/re/re.regex/re.regex.assign/string.pass.cpp
@@ -17,10 +17,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r2;
     r2 = std::string("(a([bc]))");
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.const/constants.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.const/constants.pass.cpp
+++ test/std/re/re.regex/re.regex.const/constants.pass.cpp
@@ -58,8 +58,10 @@
     where(BR::egrep);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::regex_constants::awk;
 
@@ -25,4 +25,6 @@
     assert(std::regex_match("\41", std::regex("\\41", awk)));
     assert(std::regex_match("\141", std::regex("\\141", awk)));
     assert(std::regex_match("\141" "1", std::regex("\\1411", awk)));
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
@@ -29,7 +29,7 @@
     return result;
 }
 
-int main()
+int main(int, char**)
 {
     assert(error_badbackref_thrown("\\1abc"));      // no references
     assert(error_badbackref_thrown("ab(c)\\2def")); // only one reference
@@ -41,4 +41,6 @@
     const char *pat1 = "a(b)c\\1234";
     std::regex re(pat1, pat1 + 7); // extra chars after the end.
     }
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
@@ -29,8 +29,10 @@
     return result;
 }
 
-int main()
+int main(int, char**)
 {
     assert(error_ctype_thrown("[[::]]"));
     assert(error_ctype_thrown("[[:error:]]"));
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
@@ -29,7 +29,7 @@
     return result;
 }
 
-int main()
+int main(int, char**)
 {
     assert(error_escape_thrown("[\\a]"));
     assert(error_escape_thrown("\\a"));
@@ -44,4 +44,6 @@
     assert(!error_escape_thrown("[\\cA]"));
     assert(!error_escape_thrown("\\cA"));
 
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
@@ -29,7 +29,7 @@
     return result;
 }
 
-int main()
+int main(int, char**)
 {
     assert(error_badrepeat_thrown("?a"));
     assert(error_badrepeat_thrown("*a"));
@@ -40,4 +40,6 @@
     assert(error_badrepeat_thrown("*(a+)"));
     assert(error_badrepeat_thrown("+(a+)"));
     assert(error_badrepeat_thrown("{(a+)"));
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/copy.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/copy.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/copy.pass.cpp
@@ -16,10 +16,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2 = r1;
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/deduct.fail.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/deduct.fail.cpp
+++ test/std/re/re.regex/re.regex.construct/deduct.fail.cpp
@@ -24,7 +24,7 @@
 #include <cstddef>
 
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -41,4 +41,6 @@
 
 //  Test the implicit deduction guides
 
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
@@ -31,7 +31,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 
 //  Test the explicit deduction guides
@@ -133,4 +133,6 @@
     assert(re.flags() == std::regex_constants::grep);
     assert(re.mark_count() == 0);
     }
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/default.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/default.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/default.pass.cpp
@@ -25,8 +25,10 @@
     assert(r.mark_count() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
@@ -29,7 +29,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     std::string s1("\\(a\\)");
     std::string s2("\\(a[bc]\\)");
@@ -65,4 +65,6 @@
     test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::egrep, 0);
     test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::egrep, 0);
     test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::egrep, 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
@@ -28,7 +28,7 @@
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     typedef forward_iterator<std::string::const_iterator> F;
     std::string s1("\\(a\\)");
@@ -40,4 +40,6 @@
     test(F(s2.begin()), F(s2.end()), 0);
     test(F(s3.begin()), F(s3.end()), 0);
     test(F(s4.begin()), F(s4.end()), 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
@@ -29,7 +29,7 @@
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     typedef forward_iterator<std::string::const_iterator> F;
     std::string s1("\\(a\\)");
@@ -66,4 +66,6 @@
     test(F(s2.begin()), F(s2.end()), std::regex_constants::egrep, 0);
     test(F(s3.begin()), F(s3.end()), std::regex_constants::egrep, 0);
     test(F(s4.begin()), F(s4.end()), std::regex_constants::egrep, 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
@@ -25,10 +25,12 @@
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test("\\(a\\)", 0);
     test("\\(a[bc]\\)", 0);
     test("\\(a\\([bc]\\)\\)", 0);
     test("(a([bc]))", 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
@@ -25,7 +25,7 @@
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test("\\(a\\)", std::regex_constants::basic, 1);
     test("\\(a[bc]\\)", std::regex_constants::basic, 1);
@@ -56,4 +56,6 @@
     test("\\(a[bc]\\)", std::regex_constants::egrep, 0);
     test("\\(a\\([bc]\\)\\)", std::regex_constants::egrep, 0);
     test("(a([bc]))", std::regex_constants::egrep, 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
@@ -24,7 +24,7 @@
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test("\\(a\\)", 5, 0);
     test("\\(a[bc]\\)", 9, 0);
@@ -35,4 +35,6 @@
     test("(\0)(b)(c)(d)", 9, 3);
     test("(\0)(b)(c)(d)", 3, 1);
     test("(\0)(b)(c)(d)", 0, 0);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
@@ -26,7 +26,7 @@
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test("\\(a\\)", 5, std::regex_constants::basic, 1);
     test("\\(a[bc]\\)", 9, std::regex_constants::basic, 1);
@@ -57,4 +57,6 @@
     test("\\(a[bc]\\)", 9, std::regex_constants::egrep, 0);
     test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::egrep, 0);
     test("(a([bc]))", 9, std::regex_constants::egrep, 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/string.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/string.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/string.pass.cpp
@@ -26,10 +26,12 @@
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::string("\\(a\\)"), 0);
     test(std::string("\\(a[bc]\\)"), 0);
     test(std::string("\\(a\\([bc]\\)\\)"), 0);
     test(std::string("(a([bc]))"), 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
+++ test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
@@ -27,7 +27,7 @@
     assert(r.mark_count() == mc);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::string("\\(a\\)"), std::regex_constants::basic, 1);
     test(std::string("\\(a[bc]\\)"), std::regex_constants::basic, 1);
@@ -58,4 +58,6 @@
     test(std::string("\\(a[bc]\\)"), std::regex_constants::egrep, 0);
     test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::egrep, 0);
     test(std::string("(a([bc]))"), std::regex_constants::egrep, 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
+++ test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     std::regex r;
     std::locale loc = r.imbue(std::locale(LOCALE_en_US_UTF_8));
@@ -30,4 +30,6 @@
     loc = r.imbue(std::locale("C"));
     assert(loc.name() == LOCALE_en_US_UTF_8);
     assert(r.getloc().name() == "C");
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp
+++ test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
+++ test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2;
@@ -26,4 +26,6 @@
     assert(r1.mark_count() == 0);
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
+++ test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.regex/re.regex.swap/swap.pass.cpp
===================================================================
--- test/std/re/re.regex/re.regex.swap/swap.pass.cpp
+++ test/std/re/re.regex/re.regex.swap/swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::regex r1("(a([bc]))");
     std::regex r2;
@@ -25,4 +25,6 @@
     assert(r1.mark_count() == 0);
     assert(r2.flags() == std::regex::ECMAScript);
     assert(r2.mark_count() == 2);
+
+  return 0;
 }
Index: test/std/re/re.regex/types.pass.cpp
===================================================================
--- test/std/re/re.regex/types.pass.cpp
+++ test/std/re/re.regex/types.pass.cpp
@@ -23,7 +23,7 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::basic_regex<char>::value_type, char>::value), "");
     static_assert((std::is_same<std::basic_regex<char>::traits_type, std::regex_traits<char> >::value), "");
@@ -38,4 +38,6 @@
     static_assert((std::is_same<std::basic_regex<wchar_t>::flag_type,
                                 std::regex_constants::syntax_option_type>::value), "");
     static_assert((std::is_same<std::basic_regex<wchar_t>::locale_type, std::locale>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.req/nothing_to_do.pass.cpp
===================================================================
--- test/std/re/re.req/nothing_to_do.pass.cpp
+++ test/std/re/re.req/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.acc/begin_end.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.acc/begin_end.pass.cpp
+++ test/std/re/re.results/re.results.acc/begin_end.pass.cpp
@@ -33,7 +33,9 @@
         assert(*i == m[j]);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
+++ test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
@@ -33,7 +33,9 @@
         assert(*i == m[j]);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.acc/index.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.acc/index.pass.cpp
+++ test/std/re/re.results/re.results.acc/index.pass.cpp
@@ -46,8 +46,10 @@
     assert(m[4].matched == false);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::regex_constants::ECMAScript);
     test(std::regex_constants::extended);
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.acc/length.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.acc/length.pass.cpp
+++ test/std/re/re.results/re.results.acc/length.pass.cpp
@@ -30,7 +30,9 @@
     assert(m.length(4) == m[4].length());
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.acc/position.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.acc/position.pass.cpp
+++ test/std/re/re.results/re.results.acc/position.pass.cpp
@@ -30,7 +30,9 @@
     assert(m.position(4) == std::distance(s, m[4].first));
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.acc/prefix.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.acc/prefix.pass.cpp
+++ test/std/re/re.results/re.results.acc/prefix.pass.cpp
@@ -28,7 +28,9 @@
     assert(m.prefix().matched == true);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.acc/str.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.acc/str.pass.cpp
+++ test/std/re/re.results/re.results.acc/str.pass.cpp
@@ -30,7 +30,9 @@
     assert(m.str(4) == std::string(m[4]));
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.acc/suffix.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.acc/suffix.pass.cpp
+++ test/std/re/re.results/re.results.acc/suffix.pass.cpp
@@ -28,7 +28,9 @@
     assert(m.suffix().matched == true);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.all/get_allocator.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.all/get_allocator.pass.cpp
+++ test/std/re/re.results/re.results.all/get_allocator.pass.cpp
@@ -28,8 +28,10 @@
     assert(m.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>(test_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.const/allocator.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.const/allocator.pass.cpp
+++ test/std/re/re.results/re.results.const/allocator.pass.cpp
@@ -28,8 +28,10 @@
     assert(m.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>(test_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.const/copy.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.const/copy.pass.cpp
+++ test/std/re/re.results/re.results.const/copy.pass.cpp
@@ -30,11 +30,13 @@
     assert(m1.get_allocator() == m0.get_allocator());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
 
     test<char>   (test_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.const/copy_assign.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.const/copy_assign.pass.cpp
+++ test/std/re/re.results/re.results.const/copy_assign.pass.cpp
@@ -34,7 +34,7 @@
         assert(m1.get_allocator() == Allocator());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
@@ -46,4 +46,6 @@
 //  other_allocator has POCCA -> true
     test<char>   (other_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(other_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.const/default.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.const/default.pass.cpp
+++ test/std/re/re.results/re.results.const/default.pass.cpp
@@ -26,8 +26,10 @@
     assert(m.get_allocator() == std::allocator<std::sub_match<const CharT*> >());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.const/move.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.const/move.pass.cpp
+++ test/std/re/re.results/re.results.const/move.pass.cpp
@@ -35,7 +35,7 @@
     assert(m1.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
@@ -44,4 +44,6 @@
     assert(test_alloc_base::moved == 1);
     test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
     assert(test_alloc_base::moved == 2);
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.const/move_assign.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.const/move_assign.pass.cpp
+++ test/std/re/re.results/re.results.const/move_assign.pass.cpp
@@ -35,7 +35,7 @@
         assert(m1.get_allocator() == Allocator());
 }
 
-int main()
+int main(int, char**)
 {
     test<char>   (std::allocator<std::sub_match<const char *> >());
     test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
@@ -47,4 +47,6 @@
 //  other_allocator has POCMA -> true
     test<char>   (other_allocator<std::sub_match<const char*> >(3));
     test<wchar_t>(other_allocator<std::sub_match<const wchar_t*> >(3));
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.form/form1.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.form/form1.pass.cpp
+++ test/std/re/re.results/re.results.form/form1.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::match_results<const char*> m;
@@ -152,4 +152,6 @@
         assert(r == out + 34);
         assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.form/form2.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.form/form2.pass.cpp
+++ test/std/re/re.results/re.results.form/form2.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_iterators.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > nstr;
     typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> > wstr;
@@ -99,4 +99,6 @@
         assert(r == out + 34);
         assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.form/form3.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.form/form3.pass.cpp
+++ test/std/re/re.results/re.results.form/form3.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > nstr;
     typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> > wstr;
@@ -82,4 +82,6 @@
         wstr out = m.format(fmt, std::regex_constants::format_sed);
         assert(out == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.form/form4.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.form/form4.pass.cpp
+++ test/std/re/re.results/re.results.form/form4.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::match_results<const char*> m;
@@ -77,4 +77,6 @@
         std::wstring out = m.format(fmt, std::regex_constants::format_sed);
         assert(out == L"match: cdefghi, m[1]: efg, m[2]: e");
     }
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.nonmember/equal.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.nonmember/equal.pass.cpp
+++ test/std/re/re.results/re.results.nonmember/equal.pass.cpp
@@ -40,7 +40,9 @@
     assert(m1 == m2);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.size/empty.fail.cpp
===================================================================
--- test/std/re/re.results/re.results.size/empty.fail.cpp
+++ test/std/re/re.results/re.results.size/empty.fail.cpp
@@ -19,8 +19,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::match_results<const char*> c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.size/empty.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.size/empty.pass.cpp
+++ test/std/re/re.results/re.results.size/empty.pass.cpp
@@ -30,7 +30,9 @@
     assert(m.size() == 3);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.size/max_size.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.size/max_size.pass.cpp
+++ test/std/re/re.results/re.results.size/max_size.pass.cpp
@@ -24,8 +24,10 @@
     assert(m.max_size() > 0);
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.state/ready.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.state/ready.pass.cpp
+++ test/std/re/re.results/re.results.state/ready.pass.cpp
@@ -36,8 +36,10 @@
     assert(m.ready() == true);
 }
 
-int main()
+int main(int, char**)
 {
     test1();
     test2();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.swap/member_swap.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.swap/member_swap.pass.cpp
+++ test/std/re/re.results/re.results.swap/member_swap.pass.cpp
@@ -33,7 +33,9 @@
     assert(m2 == m1_save);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
===================================================================
--- test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
+++ test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
@@ -35,7 +35,9 @@
     assert(m2 == m1_save);
 }
 
-int main()
+int main(int, char**)
 {
     test();
+
+  return 0;
 }
Index: test/std/re/re.results/types.pass.cpp
===================================================================
--- test/std/re/re.results/types.pass.cpp
+++ test/std/re/re.results/types.pass.cpp
@@ -44,8 +44,10 @@
     static_assert((std::is_same<typename MR::string_type, std::basic_string<CharT> >::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
+
+  return 0;
 }
Index: test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
===================================================================
--- test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
+++ test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -44,4 +44,6 @@
         assert(sm.compare(string()) > 0);
         assert(sm.compare(string(L"123")) == 0);
     }
+
+  return 0;
 }
Index: test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
===================================================================
--- test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
+++ test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -50,4 +50,6 @@
         sm2.matched = true;
         assert(sm.compare(sm2) == 0);
     }
+
+  return 0;
 }
Index: test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
===================================================================
--- test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
+++ test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -42,4 +42,6 @@
         assert(sm.compare(L"") > 0);
         assert(sm.compare(L"123") == 0);
     }
+
+  return 0;
 }
Index: test/std/re/re.submatch/re.submatch.members/default.pass.cpp
===================================================================
--- test/std/re/re.submatch/re.submatch.members/default.pass.cpp
+++ test/std/re/re.submatch/re.submatch.members/default.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -30,4 +30,6 @@
         SM sm;
         assert(sm.matched == false);
     }
+
+  return 0;
 }
Index: test/std/re/re.submatch/re.submatch.members/length.pass.cpp
===================================================================
--- test/std/re/re.submatch/re.submatch.members/length.pass.cpp
+++ test/std/re/re.submatch/re.submatch.members/length.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -40,4 +40,6 @@
         sm.matched = true;
         assert(sm.length() == 3);
     }
+
+  return 0;
 }
Index: test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
===================================================================
--- test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
+++ test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -44,4 +44,6 @@
         str = sm;
         assert(str == std::wstring(L"123"));
     }
+
+  return 0;
 }
Index: test/std/re/re.submatch/re.submatch.members/str.pass.cpp
===================================================================
--- test/std/re/re.submatch/re.submatch.members/str.pass.cpp
+++ test/std/re/re.submatch/re.submatch.members/str.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef char CharT;
@@ -44,4 +44,6 @@
         str = sm.str();
         assert(str == std::wstring(L"123"));
     }
+
+  return 0;
 }
Index: test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
===================================================================
--- test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
+++ test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
@@ -276,7 +276,7 @@
     assert((sm1 >= y[0]) == (x >= string(1, y[0])));
 }
 
-int main()
+int main(int, char**)
 {
     test(std::string("123"), std::string("123"));
     test(std::string("1234"), std::string("123"));
@@ -284,4 +284,6 @@
     test(std::wstring(L"1234"), std::wstring(L"123"));
     test(std::string("123\000" "56", 6), std::string("123\000" "56", 6), false);
     test(std::wstring(L"123\000" L"56", 6), std::wstring(L"123\000" L"56", 6), false);
+
+  return 0;
 }
Index: test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
===================================================================
--- test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
+++ test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
@@ -35,8 +35,10 @@
     assert(os.str() == s);
 }
 
-int main()
+int main(int, char**)
 {
     test(std::string("123"));
     test(std::wstring(L"123"));
+
+  return 0;
 }
Index: test/std/re/re.submatch/types.pass.cpp
===================================================================
--- test/std/re/re.submatch/types.pass.cpp
+++ test/std/re/re.submatch/types.pass.cpp
@@ -27,7 +27,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::sub_match<char*> SM;
@@ -61,4 +61,6 @@
         static_assert((std::is_same<std::ssub_match, std::sub_match<std::string::const_iterator> >::value), "");
         static_assert((std::is_same<std::wssub_match, std::sub_match<std::wstring::const_iterator> >::value), "");
     }
+
+  return 0;
 }
Index: test/std/re/re.syn/cmatch.pass.cpp
===================================================================
--- test/std/re/re.syn/cmatch.pass.cpp
+++ test/std/re/re.syn/cmatch.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::match_results<const char*>, std::cmatch>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/cregex_iterator.pass.cpp
===================================================================
--- test/std/re/re.syn/cregex_iterator.pass.cpp
+++ test/std/re/re.syn/cregex_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_iterator<const char*>, std::cregex_iterator>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/cregex_token_iterator.pass.cpp
===================================================================
--- test/std/re/re.syn/cregex_token_iterator.pass.cpp
+++ test/std/re/re.syn/cregex_token_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_token_iterator<const char*>, std::cregex_token_iterator>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/csub_match.pass.cpp
===================================================================
--- test/std/re/re.syn/csub_match.pass.cpp
+++ test/std/re/re.syn/csub_match.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::sub_match<const char*>, std::csub_match>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/regex.pass.cpp
===================================================================
--- test/std/re/re.syn/regex.pass.cpp
+++ test/std/re/re.syn/regex.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::basic_regex<char>, std::regex>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/smatch.pass.cpp
===================================================================
--- test/std/re/re.syn/smatch.pass.cpp
+++ test/std/re/re.syn/smatch.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::match_results<std::string::const_iterator>, std::smatch>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/sregex_iterator.pass.cpp
===================================================================
--- test/std/re/re.syn/sregex_iterator.pass.cpp
+++ test/std/re/re.syn/sregex_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_iterator<std::string::const_iterator>, std::sregex_iterator>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/sregex_token_iterator.pass.cpp
===================================================================
--- test/std/re/re.syn/sregex_token_iterator.pass.cpp
+++ test/std/re/re.syn/sregex_token_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_token_iterator<std::string::const_iterator>, std::sregex_token_iterator>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/ssub_match.pass.cpp
===================================================================
--- test/std/re/re.syn/ssub_match.pass.cpp
+++ test/std/re/re.syn/ssub_match.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::sub_match<std::string::const_iterator>, std::ssub_match>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/wcmatch.pass.cpp
===================================================================
--- test/std/re/re.syn/wcmatch.pass.cpp
+++ test/std/re/re.syn/wcmatch.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::match_results<const wchar_t*>, std::wcmatch>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/wcregex_iterator.pass.cpp
===================================================================
--- test/std/re/re.syn/wcregex_iterator.pass.cpp
+++ test/std/re/re.syn/wcregex_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_iterator<const wchar_t*>, std::wcregex_iterator>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/wcregex_token_iterator.pass.cpp
===================================================================
--- test/std/re/re.syn/wcregex_token_iterator.pass.cpp
+++ test/std/re/re.syn/wcregex_token_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_token_iterator<const wchar_t*>, std::wcregex_token_iterator>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/wcsub_match.pass.cpp
===================================================================
--- test/std/re/re.syn/wcsub_match.pass.cpp
+++ test/std/re/re.syn/wcsub_match.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::sub_match<const wchar_t*>, std::wcsub_match>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/wregex.pass.cpp
===================================================================
--- test/std/re/re.syn/wregex.pass.cpp
+++ test/std/re/re.syn/wregex.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::basic_regex<wchar_t>, std::wregex>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/wsmatch.pass.cpp
===================================================================
--- test/std/re/re.syn/wsmatch.pass.cpp
+++ test/std/re/re.syn/wsmatch.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::match_results<std::wstring::const_iterator>, std::wsmatch>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/wsregex_iterator.pass.cpp
===================================================================
--- test/std/re/re.syn/wsregex_iterator.pass.cpp
+++ test/std/re/re.syn/wsregex_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_iterator<std::wstring::const_iterator>, std::wsregex_iterator>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/wsregex_token_iterator.pass.cpp
===================================================================
--- test/std/re/re.syn/wsregex_token_iterator.pass.cpp
+++ test/std/re/re.syn/wsregex_token_iterator.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_token_iterator<std::wstring::const_iterator>, std::wsregex_token_iterator>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.syn/wssub_match.pass.cpp
===================================================================
--- test/std/re/re.syn/wssub_match.pass.cpp
+++ test/std/re/re.syn/wssub_match.pass.cpp
@@ -14,7 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::sub_match<std::wstring::const_iterator>, std::wssub_match>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.traits/default.pass.cpp
===================================================================
--- test/std/re/re.traits/default.pass.cpp
+++ test/std/re/re.traits/default.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t1;
@@ -36,4 +36,6 @@
         std::regex_traits<wchar_t> t2;
         assert(t2.getloc().name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
Index: test/std/re/re.traits/getloc.pass.cpp
===================================================================
--- test/std/re/re.traits/getloc.pass.cpp
+++ test/std/re/re.traits/getloc.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t1;
@@ -35,4 +35,6 @@
         std::regex_traits<wchar_t> t2;
         assert(t2.getloc().name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
Index: test/std/re/re.traits/imbue.pass.cpp
===================================================================
--- test/std/re/re.traits/imbue.pass.cpp
+++ test/std/re/re.traits/imbue.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -29,4 +29,6 @@
         assert(loc.name() == "C");
         assert(t.getloc().name() == LOCALE_en_US_UTF_8);
     }
+
+  return 0;
 }
Index: test/std/re/re.traits/isctype.pass.cpp
===================================================================
--- test/std/re/re.traits/isctype.pass.cpp
+++ test/std/re/re.traits/isctype.pass.cpp
@@ -20,7 +20,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -280,4 +280,6 @@
         assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
         assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
     }
+
+  return 0;
 }
Index: test/std/re/re.traits/length.pass.cpp
===================================================================
--- test/std/re/re.traits/length.pass.cpp
+++ test/std/re/re.traits/length.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::regex_traits<char>::length("") == 0);
     assert(std::regex_traits<char>::length("1") == 1);
@@ -28,4 +28,6 @@
     assert(std::regex_traits<wchar_t>::length(L"1") == 1);
     assert(std::regex_traits<wchar_t>::length(L"12") == 2);
     assert(std::regex_traits<wchar_t>::length(L"123") == 3);
+
+  return 0;
 }
Index: test/std/re/re.traits/lookup_classname.pass.cpp
===================================================================
--- test/std/re/re.traits/lookup_classname.pass.cpp
+++ test/std/re/re.traits/lookup_classname.pass.cpp
@@ -53,7 +53,7 @@
       assert(!matches_underscore && "should not match underscore");
 }
 
-int main()
+int main(int, char**)
 {
 //  if __regex_word is not distinct from all the classes, bad things happen
 //  See https://bugs.llvm.org/show_bug.cgi?id=26476 for an example.
@@ -243,4 +243,6 @@
     test(L"dig", std::ctype_base::mask());
     test(L"", std::ctype_base::mask());
     test(L"digits", std::ctype_base::mask());
+
+  return 0;
 }
Index: test/std/re/re.traits/lookup_collatename.pass.cpp
===================================================================
--- test/std/re/re.traits/lookup_collatename.pass.cpp
+++ test/std/re/re.traits/lookup_collatename.pass.cpp
@@ -39,7 +39,7 @@
     assert(t.lookup_collatename(F(A), F(A + t.length(A))) == expected);
 }
 
-int main()
+int main(int, char**)
 {
     test("NUL", std::string("\x00", 1));
     test("alert", std::string("\x07"));
@@ -192,4 +192,6 @@
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     test(L"ch", std::wstring(L"ch"));
     std::locale::global(std::locale("C"));
+
+  return 0;
 }
Index: test/std/re/re.traits/transform.pass.cpp
===================================================================
--- test/std/re/re.traits/transform.pass.cpp
+++ test/std/re/re.traits/transform.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_iterators.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -45,4 +45,6 @@
         t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
         assert(t.transform(F(a), F(a+1)) < t.transform(F(B), F(B+1)));
     }
+
+  return 0;
 }
Index: test/std/re/re.traits/transform_primary.pass.cpp
===================================================================
--- test/std/re/re.traits/transform_primary.pass.cpp
+++ test/std/re/re.traits/transform_primary.pass.cpp
@@ -27,7 +27,7 @@
 #include "test_iterators.h"
 #include "platform_support.h" // locale name macros
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -51,4 +51,6 @@
         assert(t.transform_primary(F(A), F(A+1)) ==
                t.transform_primary(F(Aacute), F(Aacute+1)));
     }
+
+  return 0;
 }
Index: test/std/re/re.traits/translate.pass.cpp
===================================================================
--- test/std/re/re.traits/translate.pass.cpp
+++ test/std/re/re.traits/translate.pass.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -31,4 +31,6 @@
         assert(t.translate(L'B') == L'B');
         assert(t.translate(L'c') == L'c');
     }
+
+  return 0;
 }
Index: test/std/re/re.traits/translate_nocase.pass.cpp
===================================================================
--- test/std/re/re.traits/translate_nocase.pass.cpp
+++ test/std/re/re.traits/translate_nocase.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "platform_support.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -61,4 +61,6 @@
         assert(t.translate_nocase(L'\xDA') == L'\xFA');
         assert(t.translate_nocase(L'\xFA') == L'\xFA');
     }
+
+  return 0;
 }
Index: test/std/re/re.traits/types.pass.cpp
===================================================================
--- test/std/re/re.traits/types.pass.cpp
+++ test/std/re/re.traits/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::regex_traits<char>::char_type, char>::value), "");
     static_assert((std::is_same<std::regex_traits<char>::string_type, std::string>::value), "");
@@ -29,4 +29,6 @@
     static_assert((std::is_same<std::regex_traits<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::regex_traits<wchar_t>::string_type, std::wstring>::value), "");
     static_assert((std::is_same<std::regex_traits<wchar_t>::locale_type, std::locale>::value), "");
+
+  return 0;
 }
Index: test/std/re/re.traits/value.pass.cpp
===================================================================
--- test/std/re/re.traits/value.pass.cpp
+++ test/std/re/re.traits/value.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::regex_traits<char> t;
@@ -122,4 +122,6 @@
             assert(t.value(c, 16) == -1);
         }
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string.hash/enabled_hashes.pass.cpp
===================================================================
--- test/std/strings/basic.string.hash/enabled_hashes.pass.cpp
+++ test/std/strings/basic.string.hash/enabled_hashes.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::string>();
@@ -30,4 +30,6 @@
     test_hash_enabled_for_type<std::u32string>();
 #endif
   }
+
+  return 0;
 }
Index: test/std/strings/basic.string.hash/strings.pass.cpp
===================================================================
--- test/std/strings/basic.string.hash/strings.pass.cpp
+++ test/std/strings/basic.string.hash/strings.pass.cpp
@@ -40,7 +40,7 @@
     assert(h(s1) != h(s2));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::string>();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -51,4 +51,6 @@
     test<std::u32string>();
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::wstring>();
+
+  return 0;
 }
Index: test/std/strings/basic.string.literals/literal.pass.cpp
===================================================================
--- test/std/strings/basic.string.literals/literal.pass.cpp
+++ test/std/strings/basic.string.literals/literal.pass.cpp
@@ -21,7 +21,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::string_literals;
 
@@ -54,4 +54,6 @@
     Lfoo  =  L"ABC"s;     assert( Lfoo ==  L"ABC");   assert( Lfoo == std::wstring  ( L"ABC"));
     ufoo  =  u"ABC"s;     assert( ufoo ==  u"ABC");   assert( ufoo == std::u16string( u"ABC"));
     Ufoo  =  U"ABC"s;     assert( Ufoo ==  U"ABC");   assert( Ufoo == std::u32string( U"ABC"));
+
+  return 0;
 }
Index: test/std/strings/basic.string.literals/literal1.fail.cpp
===================================================================
--- test/std/strings/basic.string.literals/literal1.fail.cpp
+++ test/std/strings/basic.string.literals/literal1.fail.cpp
@@ -12,9 +12,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using std::string;
 
     string foo  =   ""s;  // should fail w/conversion operator not found
+
+  return 0;
 }
Index: test/std/strings/basic.string.literals/literal1.pass.cpp
===================================================================
--- test/std/strings/basic.string.literals/literal1.pass.cpp
+++ test/std/strings/basic.string.literals/literal1.pass.cpp
@@ -12,9 +12,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals;
 
     std::string foo  =   ""s;
+
+  return 0;
 }
Index: test/std/strings/basic.string.literals/literal2.fail.cpp
===================================================================
--- test/std/strings/basic.string.literals/literal2.fail.cpp
+++ test/std/strings/basic.string.literals/literal2.fail.cpp
@@ -12,7 +12,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string foo  =   ""s;  // should fail w/conversion operator not found
+
+  return 0;
 }
Index: test/std/strings/basic.string.literals/literal2.pass.cpp
===================================================================
--- test/std/strings/basic.string.literals/literal2.pass.cpp
+++ test/std/strings/basic.string.literals/literal2.pass.cpp
@@ -12,9 +12,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::string_literals;
 
     std::string foo  =   ""s;
+
+  return 0;
 }
Index: test/std/strings/basic.string.literals/literal3.pass.cpp
===================================================================
--- test/std/strings/basic.string.literals/literal3.pass.cpp
+++ test/std/strings/basic.string.literals/literal3.pass.cpp
@@ -12,9 +12,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std;
 
     string foo  =   ""s;
+
+  return 0;
 }
Index: test/std/strings/basic.string/allocator_mismatch.fail.cpp
===================================================================
--- test/std/strings/basic.string/allocator_mismatch.fail.cpp
+++ test/std/strings/basic.string/allocator_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <string>
 
-int main()
+int main(int, char**)
 {
     std::basic_string<char, std::char_traits<char>, std::allocator<int> > s;
+
+  return 0;
 }
Index: test/std/strings/basic.string/char.bad.fail.cpp
===================================================================
--- test/std/strings/basic.string/char.bad.fail.cpp
+++ test/std/strings/basic.string/char.bad.fail.cpp
@@ -26,7 +26,7 @@
     int two;
 };
 
-int main()
+int main(int, char**)
 {
     {
 //  array
@@ -49,4 +49,6 @@
     std::basic_string<NotStandardLayout, test_traits<NotStandardLayout> > s;
 //  expected-error-re@string:* {{static_assert failed{{.*}} "Character type of basic_string must be standard-layout"}}
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.access/at.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/at.pass.cpp
+++ test/std/strings/basic.string/string.access/at.pass.cpp
@@ -54,7 +54,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -74,4 +74,6 @@
     test(S("123"), 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.access/back.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/back.pass.cpp
+++ test/std/strings/basic.string/string.access/back.pass.cpp
@@ -31,7 +31,7 @@
     assert(s.back() == typename S::value_type('z'));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -52,4 +52,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.access/db_back.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/db_back.pass.cpp
+++ test/std/strings/basic.string/string.access/db_back.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -46,8 +46,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.access/db_cback.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/db_cback.pass.cpp
+++ test/std/strings/basic.string/string.access/db_cback.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -42,8 +42,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.access/db_cfront.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/db_cfront.pass.cpp
+++ test/std/strings/basic.string/string.access/db_cfront.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -42,8 +42,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.access/db_cindex.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/db_cindex.pass.cpp
+++ test/std/strings/basic.string/string.access/db_cindex.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,8 +44,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.access/db_front.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/db_front.pass.cpp
+++ test/std/strings/basic.string/string.access/db_front.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -46,8 +46,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.access/db_index.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/db_index.pass.cpp
+++ test/std/strings/basic.string/string.access/db_index.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,8 +44,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.access/front.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/front.pass.cpp
+++ test/std/strings/basic.string/string.access/front.pass.cpp
@@ -31,7 +31,7 @@
     assert(s.front() == typename S::value_type('z'));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -52,4 +52,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.access/index.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.access/index.pass.cpp
+++ test/std/strings/basic.string/string.access/index.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -59,4 +59,6 @@
         assert(false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/capacity.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/capacity.pass.cpp
+++ test/std/strings/basic.string/string.capacity/capacity.pass.cpp
@@ -40,7 +40,7 @@
     S::allocator_type::throw_after = INT_MAX;
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > S;
@@ -60,4 +60,6 @@
     assert(s.capacity() > 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/clear.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/clear.pass.cpp
+++ test/std/strings/basic.string/string.capacity/clear.pass.cpp
@@ -23,7 +23,7 @@
     assert(s.size() == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -53,4 +53,6 @@
     test(s);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/empty.fail.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/empty.fail.cpp
+++ test/std/strings/basic.string/string.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::string c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/empty.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/empty.pass.cpp
+++ test/std/strings/basic.string/string.capacity/empty.pass.cpp
@@ -24,7 +24,7 @@
     assert(s.empty() == (s.size() == 0));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -40,4 +40,6 @@
     test(S("12345678901234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/length.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/length.pass.cpp
+++ test/std/strings/basic.string/string.capacity/length.pass.cpp
@@ -22,7 +22,7 @@
     assert(s.length() == s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -38,4 +38,6 @@
     test(S("12345678901234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/max_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/max_size.pass.cpp
+++ test/std/strings/basic.string/string.capacity/max_size.pass.cpp
@@ -54,7 +54,7 @@
     test2(s);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -70,4 +70,6 @@
     test(S("12345678901234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
+++ test/std/strings/basic.string/string.capacity/over_max_size.pass.cpp
@@ -35,7 +35,7 @@
     assert ( false );
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -51,4 +51,6 @@
     test(S("12345678901234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/reserve.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/reserve.pass.cpp
+++ test/std/strings/basic.string/string.capacity/reserve.pass.cpp
@@ -65,7 +65,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -131,4 +131,6 @@
     }
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
+++ test/std/strings/basic.string/string.capacity/resize_size.pass.cpp
@@ -43,7 +43,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@
     test(S(), S::npos, S("not going to happen"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
+++ test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp
@@ -43,7 +43,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@
     test(S(), S::npos, 'a', S("not going to happen"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
+++ test/std/strings/basic.string/string.capacity/shrink_to_fit.pass.cpp
@@ -29,7 +29,7 @@
     assert(s.capacity() >= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -59,4 +59,6 @@
     test(s);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.capacity/size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.capacity/size.pass.cpp
+++ test/std/strings/basic.string/string.capacity/size.pass.cpp
@@ -22,7 +22,7 @@
     assert(s.size() == c);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -38,4 +38,6 @@
     test(S("12345678901234567890123456789012345678901234567890"), 50);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
+++ test/std/strings/basic.string/string.cons/T_size_size.pass.cpp
@@ -91,7 +91,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -183,4 +183,6 @@
     S s7(s.data(), 2);     // calls ctor(const char *, len)
     assert(s7 == "AB");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/alloc.pass.cpp
@@ -85,11 +85,13 @@
 
 #endif
 
-int main()
+int main(int, char**)
 {
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char> > >();
 #if TEST_STD_VER >= 11
     test2<std::basic_string<char, std::char_traits<char>, min_allocator<char> > >();
     test2<std::basic_string<char, std::char_traits<char>, explicit_allocator<char> > >();
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
+++ test/std/strings/basic.string/string.cons/brace_assignment.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   // Test that assignment from {} and {ptr, len} are allowed and are not
   // ambiguous.
@@ -32,4 +32,6 @@
     s = {"abc", 2};
     assert(s == "ab");
   }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
+++ test/std/strings/basic.string/string.cons/char_assignment.pass.cpp
@@ -28,7 +28,7 @@
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -46,4 +46,6 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), 'a');
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/copy.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/copy.pass.cpp
+++ test/std/strings/basic.string/string.cons/copy.pass.cpp
@@ -28,7 +28,7 @@
     assert(s2.get_allocator() == s1.get_allocator());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -46,4 +46,6 @@
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
@@ -87,7 +87,7 @@
     assert(s2.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -127,4 +127,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
+++ test/std/strings/basic.string/string.cons/copy_assignment.pass.cpp
@@ -27,7 +27,7 @@
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -76,4 +76,6 @@
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
+++ test/std/strings/basic.string/string.cons/default_noexcept.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -35,4 +35,6 @@
         typedef std::basic_string<char, std::char_traits<char>, limited_allocator<char, 10>> C;
         static_assert(!std::is_nothrow_default_constructible<C>::value, "");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
+++ test/std/strings/basic.string/string.cons/dtor_noexcept.pass.cpp
@@ -32,7 +32,7 @@
 std::string s;
 std::wstring ws;
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -48,4 +48,6 @@
         static_assert(!std::is_nothrow_destructible<C>::value, "");
     }
 #endif // _LIBCPP_VERSION
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
+++ test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
@@ -46,7 +46,7 @@
 // (13) basic_string(initializer_list<CharT>, A const& = A())
 // (14) basic_string(BSV, A const& = A())
 // (15) basic_string(const T&, size_type, size_type, A const& = A())
-int main()
+int main(int, char**)
 {
   using TestSizeT = test_allocator<char>::size_type;
   { // Testing (1)
@@ -313,4 +313,6 @@
     ASSERT_SAME_TYPE(decltype(w), ExpectW);
     assert(w == L"cd");
   }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
+++ test/std/strings/basic.string/string.cons/initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s = {'a', 'b', 'c'};
@@ -40,4 +40,6 @@
         s = {L'a', L'b', L'c'};
         assert(s == L"abc");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
+++ test/std/strings/basic.string/string.cons/initializer_list_assignment.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s;
@@ -30,4 +30,6 @@
         s = {'a', 'b', 'c'};
         assert(s == "abc");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -56,7 +56,7 @@
     assert(s2.capacity() >= s2.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -116,4 +116,6 @@
     test(input_iterator<const char*>(s), input_iterator<const char*>(s+50), A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp
+++ test/std/strings/basic.string/string.cons/iter_alloc_deduction.fail.cpp
@@ -35,7 +35,7 @@
 template <typename T>
 struct NotAnAllocator { typedef T value_type; };
 
-int main()
+int main(int, char**)
 {
     { // Not an iterator at all
     std::basic_string s1{NotAnItertor{}, NotAnItertor{}, std::allocator<char>{}}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_string'}}
@@ -52,4 +52,6 @@
     std::basic_string s1{s, s+10, NotAnAllocator<wchar_t>{}}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_string'}}
     }
 
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
+++ test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
@@ -36,7 +36,7 @@
 #include "../input_iterator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     const char* s = "12345678901234";
@@ -89,4 +89,6 @@
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/move.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/move.pass.cpp
+++ test/std/strings/basic.string/string.cons/move.pass.cpp
@@ -32,7 +32,7 @@
     assert(s2.get_allocator() == s1.get_allocator());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -48,4 +48,6 @@
     test(S("1", A()));
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
@@ -34,7 +34,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -74,4 +74,6 @@
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
+++ test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
@@ -62,7 +62,7 @@
     typedef std::false_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -93,4 +93,6 @@
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
+++ test/std/strings/basic.string/string.cons/move_assignment.pass.cpp
@@ -32,7 +32,7 @@
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -70,4 +70,6 @@
            "1234567890123456789012345678901234567890123456789012345678901234567890"),
          S("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
+++ test/std/strings/basic.string/string.cons/move_noexcept.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -39,4 +39,6 @@
         static_assert( std::is_nothrow_move_constructible<C>::value, "");
 #endif
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
@@ -51,7 +51,7 @@
     assert(s2.capacity() >= s2.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -85,4 +85,6 @@
     test("123456798012345679801234567980123456798012345679801234567980", A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
+++ test/std/strings/basic.string/string.cons/pointer_assignment.pass.cpp
@@ -29,7 +29,7 @@
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -69,4 +69,6 @@
          "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/pointer_size_alloc.pass.cpp
@@ -48,7 +48,7 @@
     assert(s2.capacity() >= s2.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -90,4 +90,6 @@
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
+++ test/std/strings/basic.string/string.cons/size_char_alloc.pass.cpp
@@ -80,7 +80,7 @@
     assert(s2.capacity() >= s2.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -120,4 +120,6 @@
     test(static_cast<char>(100), static_cast<char>(65), A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/string_view.fail.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/string_view.fail.cpp
+++ test/std/strings/basic.string/string.cons/string_view.fail.cpp
@@ -15,8 +15,10 @@
 
 void foo ( const string &s ) {}
 
-int main()
+int main(int, char**)
 {
     std::string_view sv = "ABCDE";
     foo(sv);    // requires implicit conversion from string_view to string
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/string_view.pass.cpp
+++ test/std/strings/basic.string/string.cons/string_view.pass.cpp
@@ -71,7 +71,7 @@
   }
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -107,4 +107,6 @@
     test(SV("123456798012345679801234567980123456798012345679801234567980"), A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
+++ test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
@@ -28,7 +28,7 @@
     assert(s1.capacity() >= s1.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -70,4 +70,6 @@
          SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp
+++ test/std/strings/basic.string/string.cons/string_view_deduction.fail.cpp
@@ -31,10 +31,12 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 23}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_string'}}
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
+++ test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
@@ -38,7 +38,7 @@
 #include "../input_iterator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string_view sv = "12345678901234";
@@ -103,4 +103,6 @@
     assert(s1.size() == sv.size());
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp
+++ test/std/strings/basic.string/string.cons/string_view_size_size_deduction.fail.cpp
@@ -37,10 +37,12 @@
 #include <cassert>
 #include <cstddef>
 
-int main()
+int main(int, char**)
 {
     {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4, 23}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'basic_string'}}
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
+++ test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
@@ -42,7 +42,7 @@
 #include "../input_iterator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::string_view sv = "12345678901234";
@@ -107,4 +107,6 @@
     assert(s1.size() == 4);
     assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.cons/substr.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.cons/substr.pass.cpp
+++ test/std/strings/basic.string/string.cons/substr.pass.cpp
@@ -140,7 +140,7 @@
 #endif
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -224,4 +224,6 @@
     test2583();
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
+++ test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -30,4 +30,6 @@
     assert ( s2.ends_with('e'));
     assert (!s2.ends_with('x'));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
+++ test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -59,4 +59,6 @@
     assert (!sNot.ends_with("abcde"));
     assert ( sNot.ends_with("def"));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
+++ test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -68,4 +68,6 @@
     assert (!sNot.ends_with(sv5));
     assert ( sNot.ends_with(svNot));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.iterators/begin.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/begin.pass.cpp
+++ test/std/strings/basic.string/string.iterators/begin.pass.cpp
@@ -30,7 +30,7 @@
     assert(b == cb);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,4 +44,6 @@
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
+++ test/std/strings/basic.string/string.iterators/cbegin.pass.cpp
@@ -27,7 +27,7 @@
     assert(cb == s.begin());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -41,4 +41,6 @@
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.iterators/cend.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/cend.pass.cpp
+++ test/std/strings/basic.string/string.iterators/cend.pass.cpp
@@ -23,7 +23,7 @@
     assert(ce == s.end());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -37,4 +37,6 @@
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
+++ test/std/strings/basic.string/string.iterators/crbegin.pass.cpp
@@ -27,7 +27,7 @@
     assert(cb == s.rbegin());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -41,4 +41,6 @@
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.iterators/crend.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/crend.pass.cpp
+++ test/std/strings/basic.string/string.iterators/crend.pass.cpp
@@ -23,7 +23,7 @@
     assert(ce == s.rend());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -37,4 +37,6 @@
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
+++ test/std/strings/basic.string/string.iterators/db_iterators_2.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,8 +44,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
+++ test/std/strings/basic.string/string.iterators/db_iterators_3.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,8 +44,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
+++ test/std/strings/basic.string/string.iterators/db_iterators_4.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -46,8 +46,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
+++ test/std/strings/basic.string/string.iterators/db_iterators_5.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -50,8 +50,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
+++ test/std/strings/basic.string/string.iterators/db_iterators_6.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -48,8 +48,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
+++ test/std/strings/basic.string/string.iterators/db_iterators_7.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -48,8 +48,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
+++ test/std/strings/basic.string/string.iterators/db_iterators_8.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string C;
@@ -44,8 +44,10 @@
 
 #else
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
 #endif
Index: test/std/strings/basic.string/string.iterators/end.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/end.pass.cpp
+++ test/std/strings/basic.string/string.iterators/end.pass.cpp
@@ -33,7 +33,7 @@
     assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -47,4 +47,6 @@
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.iterators/iterators.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/iterators.pass.cpp
+++ test/std/strings/basic.string/string.iterators/iterators.pass.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     { // N3644 testing
         typedef std::string C;
@@ -83,4 +83,6 @@
         assert ( !(ii1 != ii2 ));
         assert ( !(ii1 != cii ));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
+++ test/std/strings/basic.string/string.iterators/rbegin.pass.cpp
@@ -30,7 +30,7 @@
     assert(b == cb);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -44,4 +44,6 @@
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.iterators/rend.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.iterators/rend.pass.cpp
+++ test/std/strings/basic.string/string.iterators/rend.pass.cpp
@@ -33,7 +33,7 @@
     assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -47,4 +47,6 @@
     test(S("123"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp
@@ -71,7 +71,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -196,4 +196,6 @@
     s.append(sv, 0, std::string::npos);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123");
@@ -31,4 +31,6 @@
         s.append({'a', 'b', 'c'});
         assert(s == "123abc");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -42,7 +42,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -219,4 +219,6 @@
     s.append(MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
@@ -26,7 +26,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -76,4 +76,6 @@
     s_long.append(s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
@@ -27,7 +27,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@
     s_long.append(s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
@@ -31,7 +31,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -56,4 +56,6 @@
     s.push_back(vl);
     s.push_back(vl);
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/size_char.pass.cpp
@@ -26,7 +26,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -60,4 +60,6 @@
     test(S("12345678901234567890"), 10, 'a', S("12345678901234567890aaaaaaaaaa"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/string.pass.cpp
@@ -26,7 +26,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp
@@ -71,7 +71,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -133,4 +133,6 @@
     test_npos(S(), S("12345"), 5, S(""));
     test_npos(S(), S("12345"), 6, S("not happening"));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_append/string_view.pass.cpp
@@ -27,7 +27,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -79,4 +79,6 @@
          S("1234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp
@@ -70,7 +70,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -191,4 +191,6 @@
     s.assign(sv, 0, std::string::npos);
     assert(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123");
@@ -31,4 +31,6 @@
         s.assign({'a', 'b', 'c'});
         assert(s == "abc");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -43,7 +43,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -204,4 +204,6 @@
     s.assign(p, p + 4);
     assert(s == "ABCD");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
@@ -26,7 +26,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -74,4 +74,6 @@
     s_long.assign(s_long.c_str() + 30);
     assert(s_long == "nsectetur/");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
@@ -27,7 +27,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@
     s_long.assign(s_long.data() + 2, 8 );
     assert(s_long == "rem ipsu");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/rv_string.pass.cpp
@@ -27,7 +27,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -77,4 +77,6 @@
          S("12345678901234567890"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/size_char.pass.cpp
@@ -26,7 +26,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -60,4 +60,6 @@
     test(S("12345678901234567890"), 10, 'a', S(10, 'a'));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp
@@ -37,7 +37,7 @@
     assert(s.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -113,4 +113,6 @@
     static_assert(noexcept(S().assign(S())), "");  // LWG#2063
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp
@@ -71,7 +71,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -133,4 +133,6 @@
     test_npos(S(), S("12345"), 5, S(""));
     test_npos(S(), S("12345"), 6, S("not happening"));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_assign/string_view.pass.cpp
@@ -38,7 +38,7 @@
     assert(s.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -101,4 +101,6 @@
     testAlloc(S(), SV("12345678901234567890"), min_allocator<char>());
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp
@@ -49,7 +49,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -177,4 +177,6 @@
     test(S("abcdefghijklmnopqrst"), s, 21, 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_erase/iter.pass.cpp
@@ -28,7 +28,7 @@
     assert(i - s.begin() == pos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -62,4 +62,6 @@
     test(S("abcdefghijklmnopqrst"), 19, S("abcdefghijklmnopqrs"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_erase/iter_iter.pass.cpp
@@ -29,7 +29,7 @@
     assert(i - s.begin() == pos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -147,4 +147,6 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, S("abcdefghijklmnopqrst"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_erase/pop_back.pass.cpp
@@ -26,7 +26,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -42,4 +42,6 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrs"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp
@@ -88,7 +88,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -298,4 +298,6 @@
     test(S("abcdefghijklmnopqrst"), S(""));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/iter_char.pass.cpp
@@ -32,7 +32,7 @@
         assert(i == p);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -72,4 +72,6 @@
     test(s, s.begin()+6, 'C', S("a567ABC1432dcb"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/iter_initializer_list.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123456");
@@ -33,4 +33,6 @@
         assert(i - s.begin() == 3);
         assert(s == "123abc456");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -49,7 +49,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -218,4 +218,6 @@
     s.insert(s.begin(), MoveIt(It(std::begin(p))), MoveIt(It(std::end(p) - 1)));
     assert(s == "ABCD");
   }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/iter_size_char.pass.cpp
@@ -28,7 +28,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -166,4 +166,6 @@
     test(S("abcdefghijklmnopqrst"), 20, 20, '1', S("abcdefghijklmnopqrst11111111111111111111"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp
@@ -1729,7 +1729,7 @@
     test_npos(S("abcdefghijklmnopqrst"), 10, SV("12345"), 6, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1838,4 +1838,6 @@
     assert(s == "");
     s.clear();
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
@@ -47,7 +47,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -233,4 +233,6 @@
     s_long.insert(0, s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
@@ -48,7 +48,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -714,4 +714,6 @@
     s_long.insert(0, s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp
@@ -48,7 +48,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -218,4 +218,6 @@
     test(S("abcdefghijklmnopqrst"), 21, 20, '1', S("can't happen"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp
@@ -47,7 +47,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -226,4 +226,6 @@
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp
@@ -1727,7 +1727,7 @@
     test_npos(S("abcdefghijklmnopqrst"), 10, S("12345"), 6, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1799,4 +1799,6 @@
     test30<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
@@ -47,7 +47,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -235,4 +235,6 @@
     s_long.insert(0, s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_op_plus_equal/char.pass.cpp
@@ -25,7 +25,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -43,4 +43,6 @@
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_op_plus_equal/initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123");
@@ -30,4 +30,6 @@
         s += {'a', 'b', 'c'};
         assert(s == "123abc");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_op_plus_equal/pointer.pass.cpp
@@ -25,7 +25,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -75,4 +75,6 @@
          S("1234567890123456789012345678901234567890"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_op_plus_equal/string.pass.cpp
@@ -26,7 +26,7 @@
     assert(s == expected);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -85,4 +85,6 @@
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_initializer_list.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("123def456");
@@ -30,4 +30,6 @@
         s.replace(s.cbegin() + 3, s.cbegin() + 6, {'a', 'b', 'c'});
         assert(s == "123abc456");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -963,7 +963,7 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+20, S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1036,4 +1036,6 @@
     s.replace(s.begin(), s.end(), p, p + 4);
     assert(s == "EFGH");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
@@ -265,7 +265,7 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -297,4 +297,6 @@
     s_long.replace(s_long.begin(), s_long.begin(), s_long.c_str());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
@@ -943,7 +943,7 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, "12345678901234567890", 20, S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -987,4 +987,6 @@
     s_long.replace(s_long.begin(), s_long.begin(), s_long.data(), s_long.size());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_size_char.pass.cpp
@@ -265,7 +265,7 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, 20, '3', S("abcdefghijklmnopqrst33333333333333333333"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -281,4 +281,6 @@
     test2<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string.pass.cpp
@@ -264,7 +264,7 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, S("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -289,4 +289,6 @@
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
@@ -264,7 +264,7 @@
     test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -282,4 +282,6 @@
     test2<S, SV>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp
@@ -5869,7 +5869,7 @@
     test_npos(S("abcdefghij"), 9, 2, SV("12345"), 6, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -6025,4 +6025,6 @@
     s.replace(0, 4, arr, 0, std::string::npos);    // calls replace(pos1, n1, string("IJKL"), pos, npos)
     assert(s == "IJKL");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp
@@ -363,7 +363,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -379,4 +379,6 @@
     test2<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp
@@ -1297,7 +1297,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, "12345678901234567890", 20, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1331,4 +1331,6 @@
     test11<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp
@@ -364,7 +364,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, 20, '2', S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -380,4 +380,6 @@
     test2<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp
@@ -362,7 +362,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, S("12345678901234567890"), S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -387,4 +387,6 @@
     assert(s == "a");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp
@@ -5859,7 +5859,7 @@
     test_npos(S("abcdefghij"), 9, 2, S("12345"), 6, S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -5981,4 +5981,6 @@
     test55<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
@@ -362,7 +362,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), S("can't happen"));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -380,4 +380,6 @@
     test2<S, SV>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
+++ test/std/strings/basic.string/string.modifiers/string_swap/swap.pass.cpp
@@ -31,7 +31,7 @@
     assert(s2 == s1_);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -73,4 +73,6 @@
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string.io/get_line.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream in(" abc\n  def\n   ghij");
@@ -77,4 +77,6 @@
         assert(s == L"   ghij");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream in(" abc*  def**   ghij");
@@ -89,4 +89,6 @@
         assert(s == L"   ghij");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("initial text");
@@ -45,4 +45,6 @@
         getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
         assert(s == L" abc");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::string s("initial text");
@@ -45,4 +45,6 @@
         getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
         assert(s == L" abc");
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string.io/stream_extract.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::istringstream in("a bc defghij");
@@ -113,4 +113,6 @@
         assert(in.fail());
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string.io/stream_insert.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream out;
@@ -87,4 +87,6 @@
         assert(L"   " + s == out.str());
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string.special/swap.pass.cpp
@@ -33,7 +33,7 @@
     assert(s2 == s1_);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -75,4 +75,6 @@
     test(S("abcdefghijklmnopqrst"), S("12345678901234567890"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
@@ -53,7 +53,7 @@
     typedef std::true_type is_always_equal;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::string C;
@@ -81,4 +81,6 @@
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op!=/pointer_string.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op!=/string_pointer.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op!=/string_string.pass.cpp
@@ -24,7 +24,7 @@
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op!=/string_string_view.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op!=/string_view_string.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs != rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op+/char_string.pass.cpp
@@ -35,7 +35,7 @@
 }
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0('a', S(""), S("a"));
@@ -66,4 +66,6 @@
     test1('a', S("12345678901234567890"), S("a12345678901234567890"));
   }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op+/pointer_string.pass.cpp
@@ -35,7 +35,7 @@
 }
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0("", S(""), S(""));
@@ -127,4 +127,6 @@
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op+/string_char.pass.cpp
@@ -35,7 +35,7 @@
 }
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0(S(""), '1', S("1"));
@@ -66,4 +66,6 @@
     test1(S("abcdefghijklmnopqrst"), '1', S("abcdefghijklmnopqrst1"));
   }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op+/string_pointer.pass.cpp
@@ -35,7 +35,7 @@
 }
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0(S(""), "", S(""));
@@ -126,4 +126,6 @@
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_op+/string_string.pass.cpp
@@ -58,7 +58,7 @@
 
 #endif
 
-int main() {
+int main(int, char**) {
   {
     typedef std::string S;
     test0(S(""), S(""), S(""));
@@ -245,4 +245,6 @@
           S("abcdefghijklmnopqrst12345678901234567890"));
   }
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_operator==/pointer_string.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_operator==/string_pointer.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_operator==/string_string.pass.cpp
@@ -24,7 +24,7 @@
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_operator==/string_string_view.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_operator==/string_view_string.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs == rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt/pointer_string.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt/string_pointer.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt/string_string.pass.cpp
@@ -24,7 +24,7 @@
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt/string_string_view.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt/string_view_string.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs > rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt=/pointer_string.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt=/string_pointer.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string.pass.cpp
@@ -24,7 +24,7 @@
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt=/string_string_view.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_opgt=/string_view_string.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs >= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt/pointer_string.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt/string_pointer.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt/string_string.pass.cpp
@@ -24,7 +24,7 @@
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt/string_string_view.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt/string_view_string.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs < rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), false);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt=/pointer_string.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt=/string_pointer.pass.cpp
@@ -23,7 +23,7 @@
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -65,4 +65,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string.pass.cpp
@@ -24,7 +24,7 @@
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt=/string_string_view.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
+++ test/std/strings/basic.string/string.nonmembers/string_oplt=/string_view_string.pass.cpp
@@ -22,7 +22,7 @@
     assert((lhs <= rhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -66,4 +66,6 @@
     test(SV("abcdefghijklmnopqrst"), S("abcdefghijklmnopqrst"), true);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp
+++ test/std/strings/basic.string/string.ops/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
+++ test/std/strings/basic.string/string.ops/string.accessors/c_str.pass.cpp
@@ -30,7 +30,7 @@
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -48,4 +48,6 @@
     test(S("abcdefghijklmnopqrst"));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
+++ test/std/strings/basic.string/string.ops/string.accessors/data.pass.cpp
@@ -47,7 +47,7 @@
         assert(T::eq(str[0], typename S::value_type()));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -74,4 +74,6 @@
     S s4("abcdefghijklmnopqrst"); test_nonconst(s4);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
+++ test/std/strings/basic.string/string.ops/string.accessors/get_allocator.pass.cpp
@@ -23,7 +23,7 @@
     assert(s.get_allocator() == a);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef test_allocator<char> A;
@@ -43,4 +43,6 @@
     test(S("abcdefghijklmnopqrst", A()), A());
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_compare/pointer.pass.cpp
@@ -31,7 +31,7 @@
     assert(sign(s.compare(str)) == sign(x));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -73,4 +73,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
@@ -5840,7 +5840,7 @@
     test_npos(S("abcde"), 0, 0, SV("abcdefghij"), 5, -5);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -5989,4 +5989,6 @@
 //  calls compare(size, size, string(arr), 0, npos)
     assert(s.compare(0, 4, arr, 0, std::string::npos) == 0);
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
@@ -361,7 +361,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -377,4 +377,6 @@
     test2<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
@@ -1294,7 +1294,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, "abcdefghijklmnopqrst", 20, 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -1328,4 +1328,6 @@
     test11<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
@@ -360,7 +360,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, S("abcdefghijklmnopqrst"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@
     assert(s.compare(0, 1, {"abc", 1}) < 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
@@ -5836,7 +5836,7 @@
     test_npos(S("abcde"), 0, 0, S("abcdefghij"), 5, -5);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -5958,4 +5958,6 @@
     test55<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
@@ -361,7 +361,7 @@
     test(S("abcdefghijklmnopqrst"), 21, 0, SV("abcdefghijklmnopqrst"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -379,4 +379,6 @@
     test2<S, SV>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_compare/string.pass.cpp
@@ -32,7 +32,7 @@
     assert(sign(s.compare(str)) == sign(x));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -81,4 +81,6 @@
     assert(s.compare({"abc", 1}) < 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_compare/string_view.pass.cpp
@@ -31,7 +31,7 @@
     assert(sign(s.compare(sv)) == sign(x));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -75,4 +75,6 @@
     test(S("abcdefghijklmnopqrst"), SV("abcdefghijklmnopqrst"), 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.not.of/char_size.pass.cpp
@@ -34,7 +34,7 @@
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -98,4 +98,6 @@
     test(S("laenfsbridchgotmkqpj"), 'q', 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -154,4 +154,6 @@
     test1<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.not.of/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@
     test3<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.not.of/string_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@
     assert(s.find_first_not_of({"abc", 1}) == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.not.of/string_view_size.pass.cpp
@@ -139,7 +139,7 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.of/char_size.pass.cpp
@@ -34,7 +34,7 @@
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@
     test(S("laenfsbridchgotmkqpj"), 'e', 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -154,4 +154,6 @@
     test1<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.of/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@
     test3<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.of/string_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@
     assert(s.find_first_of({"abc", 1}) == std::string::npos);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.first.of/string_view_size.pass.cpp
@@ -139,7 +139,7 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.not.of/char_size.pass.cpp
@@ -34,7 +34,7 @@
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@
     test(S("laenfsbridchgotmkqpj"), 'i', 19);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -154,4 +154,6 @@
     test1<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.not.of/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@
     test3<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.not.of/string_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@
     assert(s.find_last_not_of({"abc", 1}) == s.size() - 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
@@ -139,7 +139,7 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@
 //     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.of/char_size.pass.cpp
@@ -34,7 +34,7 @@
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@
     test(S("laenfsbridchgotmkqpj"), 'm', 15);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -154,4 +154,6 @@
     test1<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.of/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@
     test3<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.of/string_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@
     assert(s.find_last_of({"abc", 1}) == std::string::npos);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find.last.of/string_view_size.pass.cpp
@@ -139,7 +139,7 @@
     test(S("pniotcfrhqsmgdkjbael"), SV("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find/char_size.pass.cpp
@@ -34,7 +34,7 @@
         assert(0 <= x && x + 1 <= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@
     test(S("abcdeabcdeabcdeabcde"), 'c', 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find/pointer_size.pass.cpp
@@ -146,7 +146,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -160,4 +160,6 @@
     test1<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@
     test3<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find/string_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@
     assert(s.find({"abc", 1}) == std::string::npos);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_find/string_view_size.pass.cpp
@@ -139,7 +139,7 @@
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_rfind/char_size.pass.cpp
@@ -34,7 +34,7 @@
         assert(x + 1 <= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -94,4 +94,6 @@
     test(S("abcdeabcdeabcdeabcde"), 'b', 16);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_rfind/pointer_size.pass.cpp
@@ -147,7 +147,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@
     test1<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_rfind/pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -383,4 +383,6 @@
     test3<S>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_rfind/string_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -161,4 +161,6 @@
     assert(s.rfind({"abc", 1}) == std::string::npos);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_rfind/string_view_size.pass.cpp
@@ -139,7 +139,7 @@
     test(S("abcdeabcdeabcdeabcde"), SV("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -155,4 +155,6 @@
     test1<S, SV>();
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
+++ test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp
@@ -47,7 +47,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -173,4 +173,6 @@
     test(S("dplqartnfgejichmoskb"), 21, 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.require/contiguous.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.require/contiguous.pass.cpp
+++ test/std/strings/basic.string/string.require/contiguous.pass.cpp
@@ -24,7 +24,7 @@
         assert ( *(c.begin() + static_cast<typename C::difference_type>(i)) == *(std::addressof(*c.begin()) + i));
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -49,4 +49,6 @@
     test_contiguous(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()));
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
+++ test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -30,4 +30,6 @@
     assert ( s2.starts_with('a'));
     assert (!s2.starts_with('x'));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
+++ test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -58,4 +58,6 @@
     assert (!sNot.starts_with("abcde"));
     assert ( sNot.starts_with("def"));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
===================================================================
--- test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
+++ test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string S;
@@ -68,4 +68,6 @@
     assert (!sNot.starts_with(sv5));
     assert ( sNot.starts_with(svNot));
     }
+
+  return 0;
 }
Index: test/std/strings/basic.string/traits_mismatch.fail.cpp
===================================================================
--- test/std/strings/basic.string/traits_mismatch.fail.cpp
+++ test/std/strings/basic.string/traits_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <string>
 
-int main()
+int main(int, char**)
 {
     std::basic_string<char, std::char_traits<wchar_t>> s;
+
+  return 0;
 }
Index: test/std/strings/basic.string/types.pass.cpp
===================================================================
--- test/std/strings/basic.string/types.pass.cpp
+++ test/std/strings/basic.string/types.pass.cpp
@@ -70,7 +70,7 @@
     static_assert(S::npos == -1, "");
 }
 
-int main()
+int main(int, char**)
 {
     test<test_traits<char>, test_allocator<char> >();
     test<std::char_traits<wchar_t>, std::allocator<wchar_t> >();
@@ -81,4 +81,6 @@
 #if TEST_STD_VER >= 11
     test<std::char_traits<char>, min_allocator<char> >();
 #endif
+
+  return 0;
 }
Index: test/std/strings/c.strings/cctype.pass.cpp
===================================================================
--- test/std/strings/c.strings/cctype.pass.cpp
+++ test/std/strings/c.strings/cctype.pass.cpp
@@ -70,7 +70,7 @@
 #error toupper defined
 #endif
 
-int main()
+int main(int, char**)
 {
 
     ASSERT_SAME_TYPE(int, decltype(std::isalnum(0)));
@@ -102,4 +102,6 @@
     assert( std::isxdigit('a'));
     assert( std::tolower('A') == 'a');
     assert( std::toupper('a') == 'A');
+
+  return 0;
 }
Index: test/std/strings/c.strings/cstring.pass.cpp
===================================================================
--- test/std/strings/c.strings/cstring.pass.cpp
+++ test/std/strings/c.strings/cstring.pass.cpp
@@ -17,7 +17,7 @@
 #error NULL not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::size_t s = 0;
     void* vp = 0;
@@ -60,4 +60,6 @@
     ASSERT_SAME_TYPE(const char*, decltype(std::strrchr(cpc, 0)));
     ASSERT_SAME_TYPE(const char*, decltype(std::strstr(cpc, cpc)));
 #endif
+
+  return 0;
 }
Index: test/std/strings/c.strings/cuchar.pass.cpp
===================================================================
--- test/std/strings/c.strings/cuchar.pass.cpp
+++ test/std/strings/c.strings/cuchar.pass.cpp
@@ -14,6 +14,8 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/strings/c.strings/cwchar.pass.cpp
===================================================================
--- test/std/strings/c.strings/cwchar.pass.cpp
+++ test/std/strings/c.strings/cwchar.pass.cpp
@@ -31,7 +31,7 @@
 #error WEOF not defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::mbstate_t mb = {};
     std::size_t s = 0;
@@ -128,4 +128,6 @@
     ASSERT_SAME_TYPE(int,                decltype(std::vwprintf(L"", va)));
     ASSERT_SAME_TYPE(int,                decltype(std::wprintf(L"")));
 #endif
+
+  return 0;
 }
Index: test/std/strings/c.strings/cwctype.pass.cpp
===================================================================
--- test/std/strings/c.strings/cwctype.pass.cpp
+++ test/std/strings/c.strings/cwctype.pass.cpp
@@ -90,7 +90,7 @@
 #error wctrans defined
 #endif
 
-int main()
+int main(int, char**)
 {
     std::wint_t w = 0;
     ASSERT_SAME_TYPE(int, decltype(std::iswalnum(w)));
@@ -113,4 +113,6 @@
     ASSERT_SAME_TYPE(std::wint_t,    decltype(std::towupper(w)));
     ASSERT_SAME_TYPE(std::wint_t,    decltype(std::towctrans(w, std::wctrans_t())));
     ASSERT_SAME_TYPE(std::wctrans_t, decltype(std::wctrans("")));
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp
+++ test/std/strings/char.traits/char.traits.require/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign2.pass.cpp
@@ -27,7 +27,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     char c = '\0';
     std::char_traits<char>::assign(c, 'a');
@@ -36,4 +36,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/assign3.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     char s2[3] = {0};
     assert(std::char_traits<char>::assign(s2, 3, char(5)) == s2);
@@ -23,4 +23,6 @@
     assert(s2[1] == char(5));
     assert(s2[2] == char(5));
     assert(std::char_traits<char>::assign(NULL, 0, char(5)) == NULL);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/compare.pass.cpp
@@ -27,7 +27,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::compare("", "", 0) == 0);
     assert(std::char_traits<char>::compare(NULL, NULL, 0) == 0);
@@ -53,4 +53,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/copy.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     char s1[] = {1, 2, 3};
     char s2[3] = {0};
@@ -25,4 +25,6 @@
     assert(s2[2] == char(3));
     assert(std::char_traits<char>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char>::copy(s1, NULL, 0) == s1);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eof.pass.cpp
@@ -15,7 +15,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::eof() == EOF);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq.pass.cpp
@@ -15,8 +15,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::eq('a', 'a'));
     assert(!std::char_traits<char>::eq('a', 'A'));
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/eq_int_type.pass.cpp
@@ -15,11 +15,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert( std::char_traits<char>::eq_int_type('a', 'a'));
     assert(!std::char_traits<char>::eq_int_type('a', 'A'));
     assert(!std::char_traits<char>::eq_int_type(std::char_traits<char>::eof(), 'A'));
     assert( std::char_traits<char>::eq_int_type(std::char_traits<char>::eof(),
                                                 std::char_traits<char>::eof()));
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/find.pass.cpp
@@ -29,7 +29,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     char s1[] = {1, 2, 3};
     assert(std::char_traits<char>::find(s1, 3, char(1)) == s1);
@@ -42,4 +42,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/length.pass.cpp
@@ -27,7 +27,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::length("") == 0);
     assert(std::char_traits<char>::length("a") == 1);
@@ -38,4 +38,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert( std::char_traits<char>::lt('\0', 'A'));
     assert(!std::char_traits<char>::lt('A', '\0'));
@@ -29,4 +29,6 @@
 
     assert( std::char_traits<char>::lt(' ', 'A'));
     assert( std::char_traits<char>::lt('A', '~'));
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/move.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     char s1[] = {1, 2, 3};
     assert(std::char_traits<char>::move(s1, s1+1, 2) == s1);
@@ -29,4 +29,6 @@
     assert(s1[2] == char(3));
     assert(std::char_traits<char>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char>::move(s1, NULL, 0) == s1);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/not_eof.pass.cpp
@@ -15,11 +15,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::not_eof('a') == 'a');
     assert(std::char_traits<char>::not_eof('A') == 'A');
     assert(std::char_traits<char>::not_eof(0) == 0);
     assert(std::char_traits<char>::not_eof(std::char_traits<char>::eof()) !=
            std::char_traits<char>::eof());
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_char_type.pass.cpp
@@ -15,9 +15,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::to_char_type('a') == 'a');
     assert(std::char_traits<char>::to_char_type('A') == 'A');
     assert(std::char_traits<char>::to_char_type(0) == 0);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/to_int_type.pass.cpp
@@ -15,9 +15,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char>::to_int_type('a') == 'a');
     assert(std::char_traits<char>::to_int_type('A') == 'A');
     assert(std::char_traits<char>::to_int_type(0) == 0);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/types.pass.cpp
@@ -19,11 +19,13 @@
 #include <string>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::char_traits<char>::char_type, char>::value), "");
     static_assert((std::is_same<std::char_traits<char>::int_type, int>::value), "");
     static_assert((std::is_same<std::char_traits<char>::off_type, std::streamoff>::value), "");
     static_assert((std::is_same<std::char_traits<char>::pos_type, std::streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char>::state_type, std::mbstate_t>::value), "");
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp
@@ -27,7 +27,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -40,4 +40,6 @@
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char16_t s2[3] = {0};
@@ -25,4 +25,6 @@
     assert(s2[2] == char16_t(5));
     assert(std::char_traits<char16_t>::assign(NULL, 0, char16_t(5)) == NULL);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp
@@ -28,7 +28,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -58,4 +58,6 @@
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char16_t s1[] = {1, 2, 3};
@@ -27,4 +27,6 @@
     assert(std::char_traits<char16_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char16_t>::copy(s1, NULL, 0) == s1);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp
@@ -15,10 +15,12 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     std::char_traits<char16_t>::int_type i = std::char_traits<char16_t>::eof();
     ((void)i); // Prevent unused warning
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -25,4 +25,6 @@
     assert(!std::char_traits<char16_t>::eq(u'a', u'A'));
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -28,4 +28,6 @@
     assert( std::char_traits<char16_t>::eq_int_type(std::char_traits<char16_t>::eof(),
                                                     std::char_traits<char16_t>::eof()));
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp
@@ -29,7 +29,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char16_t s1[] = {1, 2, 3};
@@ -44,4 +44,6 @@
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp
@@ -26,7 +26,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -41,4 +41,6 @@
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -25,4 +25,6 @@
     assert( std::char_traits<char16_t>::lt(u'A', u'a'));
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char16_t s1[] = {1, 2, 3};
@@ -31,4 +31,6 @@
     assert(std::char_traits<char16_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char16_t>::move(s1, NULL, 0) == s1);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -28,4 +28,6 @@
     assert(std::char_traits<char16_t>::not_eof(std::char_traits<char16_t>::eof()) !=
            std::char_traits<char16_t>::eof());
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -26,4 +26,6 @@
 #endif
     assert(std::char_traits<char16_t>::to_char_type(0) == 0);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -26,4 +26,6 @@
 #endif
     assert(std::char_traits<char16_t>::to_int_type(0) == 0);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <type_traits>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     static_assert((std::is_same<std::char_traits<char16_t>::char_type, char16_t>::value), "");
@@ -29,4 +29,6 @@
     static_assert((std::is_same<std::char_traits<char16_t>::pos_type, std::u16streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::state_type, std::mbstate_t>::value), "");
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp
@@ -27,7 +27,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -40,4 +40,6 @@
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char32_t s2[3] = {0};
@@ -25,4 +25,6 @@
     assert(s2[2] == char32_t(5));
     assert(std::char_traits<char32_t>::assign(NULL, 0, char32_t(5)) == NULL);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp
@@ -27,7 +27,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -57,4 +57,6 @@
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char32_t s1[] = {1, 2, 3};
@@ -27,4 +27,6 @@
     assert(std::char_traits<char32_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char32_t>::copy(s1, NULL, 0) == s1);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp
@@ -15,10 +15,12 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     std::char_traits<char32_t>::int_type i = std::char_traits<char32_t>::eof();
     ((void)i); // Prevent unused warning
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -25,4 +25,6 @@
     assert(!std::char_traits<char32_t>::eq(U'a', U'A'));
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -28,4 +28,6 @@
     assert( std::char_traits<char32_t>::eq_int_type(std::char_traits<char32_t>::eof(),
                                                     std::char_traits<char32_t>::eof()));
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp
@@ -29,7 +29,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char32_t s1[] = {1, 2, 3};
@@ -44,4 +44,6 @@
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp
@@ -26,7 +26,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -41,4 +41,6 @@
     static_assert(test_constexpr(), "" );
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -25,4 +25,6 @@
     assert( std::char_traits<char32_t>::lt(U'A', U'a'));
 #endif
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     char32_t s1[] = {1, 2, 3};
@@ -31,4 +31,6 @@
     assert(std::char_traits<char32_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char32_t>::move(s1, NULL, 0) == s1);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -28,4 +28,6 @@
     assert(std::char_traits<char32_t>::not_eof(std::char_traits<char32_t>::eof()) !=
            std::char_traits<char32_t>::eof());
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -26,4 +26,6 @@
 #endif
     assert(std::char_traits<char32_t>::to_char_type(0) == 0);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
@@ -26,4 +26,6 @@
 #endif
     assert(std::char_traits<char32_t>::to_int_type(0) == 0);
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.pass.cpp
@@ -20,7 +20,7 @@
 #include <type_traits>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     static_assert((std::is_same<std::char_traits<char32_t>::char_type, char32_t>::value), "");
@@ -29,4 +29,6 @@
     static_assert((std::is_same<std::char_traits<char32_t>::pos_type, std::u32streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char32_t>::state_type, std::mbstate_t>::value), "");
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign2.pass.cpp
@@ -25,7 +25,7 @@
     return c == u'a';
 }
 
-int main()
+int main(int, char**)
 {
     char8_t c = u8'\0';
     std::char_traits<char8_t>::assign(c, u8'a');
@@ -34,5 +34,7 @@
     static_assert(test_constexpr(), "");
 }
 #else
-int main () {}
+int main(int, char**) {
+  return 0;
+}
 #endif
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/assign3.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     char8_t s2[3] = {0};
@@ -26,4 +26,6 @@
     assert(s2[2] == char8_t(5));
     assert(std::char_traits<char8_t>::assign(NULL, 0, char8_t(5)) == NULL);
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/compare.pass.cpp
@@ -27,7 +27,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char8_t>::compare(u8"", u8"", 0) == 0);
     assert(std::char_traits<char8_t>::compare(NULL, NULL, 0) == 0);
@@ -53,5 +53,7 @@
     static_assert(test_constexpr(), "" );
 }
 #else
-int main () {}
+int main(int, char**) {
+  return 0;
+}
 #endif
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/copy.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     char8_t s1[] = {1, 2, 3};
@@ -28,4 +28,6 @@
     assert(std::char_traits<char8_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char8_t>::copy(s1, NULL, 0) == s1);
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eof.pass.cpp
@@ -16,10 +16,12 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     std::char_traits<char8_t>::int_type i = std::char_traits<char8_t>::eof();
     ((void)i); // Prevent unused warning
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq.pass.cpp
@@ -18,10 +18,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert( std::char_traits<char8_t>::eq(u8'a', u8'a'));
     assert(!std::char_traits<char8_t>::eq(u8'a', u8'A'));
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/eq_int_type.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert( std::char_traits<char8_t>::eq_int_type(u8'a', u8'a'));
@@ -27,4 +27,6 @@
     assert( std::char_traits<char8_t>::eq_int_type(std::char_traits<char8_t>::eof(),
                                                     std::char_traits<char8_t>::eof()));
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/find.pass.cpp
@@ -28,7 +28,7 @@
         && std::char_traits<char8_t>::find(p, 3, u8'4') == nullptr;
 }
 
-int main()
+int main(int, char**)
 {
     char8_t s1[] = {1, 2, 3};
     assert(std::char_traits<char8_t>::find(s1, 3, char8_t(1)) == s1);
@@ -41,5 +41,7 @@
     static_assert(test_constexpr(), "" );
 }
 #else
-int main () {}
+int main(int, char**) {
+  return 0;
+}
 #endif
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/length.pass.cpp
@@ -25,7 +25,7 @@
         && std::char_traits<char8_t>::length(u8"abcd") == 4;
 }
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<char8_t>::length(u8"") == 0);
     assert(std::char_traits<char8_t>::length(u8"a") == 1);
@@ -36,5 +36,7 @@
     static_assert(test_constexpr(), "");
 }
 #else
-int main() { }
+int main(int, char**) { 
+  return 0;
+}
 #endif
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/lt.pass.cpp
@@ -18,10 +18,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert(!std::char_traits<char8_t>::lt(u8'a', u8'a'));
     assert( std::char_traits<char8_t>::lt(u8'A', u8'a'));
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/move.pass.cpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     char8_t s1[] = {1, 2, 3};
@@ -32,4 +32,6 @@
     assert(std::char_traits<char8_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char8_t>::move(s1, NULL, 0) == s1);
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/not_eof.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert(std::char_traits<char8_t>::not_eof(u8'a') == u8'a');
@@ -27,4 +27,6 @@
     assert(std::char_traits<char8_t>::not_eof(std::char_traits<char8_t>::eof()) !=
            std::char_traits<char8_t>::eof());
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_char_type.pass.cpp
@@ -18,11 +18,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert(std::char_traits<char8_t>::to_char_type(u8'a') == u8'a');
     assert(std::char_traits<char8_t>::to_char_type(u8'A') == u8'A');
     assert(std::char_traits<char8_t>::to_char_type(0) == 0);
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/to_int_type.pass.cpp
@@ -18,11 +18,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert(std::char_traits<char8_t>::to_int_type(u8'a') == u8'a');
     assert(std::char_traits<char8_t>::to_int_type(u8'A') == u8'A');
     assert(std::char_traits<char8_t>::to_int_type(0) == 0);
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char8_t/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     static_assert((std::is_same<std::char_traits<char8_t>::char_type,  char8_t>::value), "");
@@ -30,4 +30,6 @@
     static_assert((std::is_same<std::char_traits<char8_t>::pos_type,   std::u16streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char8_t>::state_type, std::mbstate_t>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign2.pass.cpp
@@ -27,7 +27,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     wchar_t c = L'\0';
     std::char_traits<wchar_t>::assign(c, L'a');
@@ -36,4 +36,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/assign3.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     wchar_t s2[3] = {0};
     assert(std::char_traits<wchar_t>::assign(s2, 3, wchar_t(5)) == s2);
@@ -23,4 +23,6 @@
     assert(s2[1] == wchar_t(5));
     assert(s2[2] == wchar_t(5));
     assert(std::char_traits<wchar_t>::assign(NULL, 0, wchar_t(5)) == NULL);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/compare.pass.cpp
@@ -27,7 +27,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::compare(L"", L"", 0) == 0);
     assert(std::char_traits<wchar_t>::compare(NULL, NULL, 0) == 0);
@@ -53,4 +53,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/copy.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     wchar_t s1[] = {1, 2, 3};
     wchar_t s2[3] = {0};
@@ -25,4 +25,6 @@
     assert(s2[2] == wchar_t(3));
     assert(std::char_traits<wchar_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<wchar_t>::copy(s1, NULL, 0) == s1);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eof.pass.cpp
@@ -15,7 +15,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::eof() == WEOF);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq.pass.cpp
@@ -15,8 +15,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::eq(L'a', L'a'));
     assert(!std::char_traits<wchar_t>::eq(L'a', L'A'));
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/eq_int_type.pass.cpp
@@ -15,11 +15,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert( std::char_traits<wchar_t>::eq_int_type(L'a', L'a'));
     assert(!std::char_traits<wchar_t>::eq_int_type(L'a', L'A'));
     assert(!std::char_traits<wchar_t>::eq_int_type(std::char_traits<wchar_t>::eof(), L'A'));
     assert( std::char_traits<wchar_t>::eq_int_type(std::char_traits<wchar_t>::eof(),
                                                    std::char_traits<wchar_t>::eof()));
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/find.pass.cpp
@@ -29,7 +29,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     wchar_t s1[] = {1, 2, 3};
     assert(std::char_traits<wchar_t>::find(s1, 3, wchar_t(1)) == s1);
@@ -42,4 +42,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/length.pass.cpp
@@ -26,7 +26,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::length(L"") == 0);
     assert(std::char_traits<wchar_t>::length(L"a") == 1);
@@ -37,4 +37,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/lt.pass.cpp
@@ -15,8 +15,10 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(!std::char_traits<wchar_t>::lt(L'a', L'a'));
     assert( std::char_traits<wchar_t>::lt(L'A', L'a'));
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/move.pass.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     wchar_t s1[] = {1, 2, 3};
     assert(std::char_traits<wchar_t>::move(s1, s1+1, 2) == s1);
@@ -29,4 +29,6 @@
     assert(s1[2] == wchar_t(3));
     assert(std::char_traits<wchar_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<wchar_t>::move(s1, NULL, 0) == s1);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/not_eof.pass.cpp
@@ -15,11 +15,13 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::not_eof(L'a') == L'a');
     assert(std::char_traits<wchar_t>::not_eof(L'A') == L'A');
     assert(std::char_traits<wchar_t>::not_eof(0) == 0);
     assert(std::char_traits<wchar_t>::not_eof(std::char_traits<wchar_t>::eof()) !=
            std::char_traits<wchar_t>::eof());
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_char_type.pass.cpp
@@ -15,9 +15,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::to_char_type(L'a') == L'a');
     assert(std::char_traits<wchar_t>::to_char_type(L'A') == L'A');
     assert(std::char_traits<wchar_t>::to_char_type(0) == 0);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/to_int_type.pass.cpp
@@ -15,9 +15,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::char_traits<wchar_t>::to_int_type(L'a') == L'a');
     assert(std::char_traits<wchar_t>::to_int_type(L'A') == L'A');
     assert(std::char_traits<wchar_t>::to_int_type(0) == 0);
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.wchar.t/types.pass.cpp
@@ -19,11 +19,13 @@
 #include <string>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::char_traits<wchar_t>::char_type, wchar_t>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::int_type, std::wint_t>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::off_type, std::streamoff>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::pos_type, std::wstreampos>::value), "");
     static_assert((std::is_same<std::char_traits<wchar_t>::state_type, std::mbstate_t>::value), "");
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp
+++ test/std/strings/char.traits/char.traits.specializations/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp
+++ test/std/strings/char.traits/char.traits.typedefs/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/strings/char.traits/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/char.traits/nothing_to_do.pass.cpp
+++ test/std/strings/char.traits/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/strings/string.classes/typedefs.pass.cpp
===================================================================
--- test/std/strings/string.classes/typedefs.pass.cpp
+++ test/std/strings/string.classes/typedefs.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::string, std::basic_string<char> >::value), "");
     static_assert((std::is_same<std::wstring, std::basic_string<wchar_t> >::value), "");
@@ -33,4 +33,6 @@
     static_assert((std::is_same<std::u16string, std::basic_string<char16_t> >::value), "");
     static_assert((std::is_same<std::u32string, std::basic_string<char32_t> >::value), "");
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
+
+  return 0;
 }
Index: test/std/strings/string.conversions/stod.pass.cpp
===================================================================
--- test/std/strings/string.conversions/stod.pass.cpp
+++ test/std/strings/string.conversions/stod.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stod("0") == 0);
     assert(std::stod(L"0") == 0);
@@ -185,4 +185,6 @@
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.conversions/stof.pass.cpp
===================================================================
--- test/std/strings/string.conversions/stof.pass.cpp
+++ test/std/strings/string.conversions/stof.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stof("0") == 0);
     assert(std::stof(L"0") == 0);
@@ -186,4 +186,6 @@
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.conversions/stoi.pass.cpp
===================================================================
--- test/std/strings/string.conversions/stoi.pass.cpp
+++ test/std/strings/string.conversions/stoi.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stoi("0") == 0);
     assert(std::stoi(L"0") == 0);
@@ -109,4 +109,6 @@
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.conversions/stol.pass.cpp
===================================================================
--- test/std/strings/string.conversions/stol.pass.cpp
+++ test/std/strings/string.conversions/stol.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stol("0") == 0);
     assert(std::stol(L"0") == 0);
@@ -113,4 +113,6 @@
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.conversions/stold.pass.cpp
===================================================================
--- test/std/strings/string.conversions/stold.pass.cpp
+++ test/std/strings/string.conversions/stold.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stold("0") == 0);
     assert(std::stold(L"0") == 0);
@@ -188,4 +188,6 @@
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.conversions/stoll.pass.cpp
===================================================================
--- test/std/strings/string.conversions/stoll.pass.cpp
+++ test/std/strings/string.conversions/stoll.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stoll("0") == 0);
     assert(std::stoll(L"0") == 0);
@@ -112,4 +112,6 @@
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.conversions/stoul.pass.cpp
===================================================================
--- test/std/strings/string.conversions/stoul.pass.cpp
+++ test/std/strings/string.conversions/stoul.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stoul("0") == 0);
     assert(std::stoul(L"0") == 0);
@@ -111,4 +111,6 @@
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.conversions/stoull.pass.cpp
===================================================================
--- test/std/strings/string.conversions/stoull.pass.cpp
+++ test/std/strings/string.conversions/stoull.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::stoull("0") == 0);
     assert(std::stoull(L"0") == 0);
@@ -112,4 +112,6 @@
         assert(idx == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.conversions/to_string.pass.cpp
===================================================================
--- test/std/strings/string.conversions/to_string.pass.cpp
+++ test/std/strings/string.conversions/to_string.pass.cpp
@@ -112,7 +112,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_signed<int>();
     test_signed<long>();
@@ -123,4 +123,6 @@
     test_float<float>();
     test_float<double>();
     test_float<long double>();
+
+  return 0;
 }
Index: test/std/strings/string.conversions/to_wstring.pass.cpp
===================================================================
--- test/std/strings/string.conversions/to_wstring.pass.cpp
+++ test/std/strings/string.conversions/to_wstring.pass.cpp
@@ -112,7 +112,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_signed<int>();
     test_signed<long>();
@@ -123,4 +123,6 @@
     test_float<float>();
     test_float<double>();
     test_float<long double>();
+
+  return 0;
 }
Index: test/std/strings/string.view/char.bad.fail.cpp
===================================================================
--- test/std/strings/string.view/char.bad.fail.cpp
+++ test/std/strings/string.view/char.bad.fail.cpp
@@ -26,7 +26,7 @@
     int two;
 };
 
-int main()
+int main(int, char**)
 {
     {
 //  array
@@ -49,4 +49,6 @@
     std::basic_string_view<NotStandardLayout, test_traits<NotStandardLayout> > sv;
 //  expected-error-re@string_view:* {{static_assert failed{{.*}} "Character type of basic_string_view must be standard-layout"}}
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp
+++ test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::string_view>();
@@ -30,4 +30,6 @@
     test_hash_enabled_for_type<std::u32string_view>();
 #endif
   }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.hash/string_view.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.hash/string_view.pass.cpp
+++ test/std/strings/string.view/string.view.hash/string_view.pass.cpp
@@ -55,7 +55,7 @@
     assert(sh(ss2) == h(s2));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::string_view>();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -66,4 +66,6 @@
     test<std::u32string_view>();
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::wstring_view>();
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.access/at.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.access/at.pass.cpp
+++ test/std/strings/string.view/string.view.access/at.pass.cpp
@@ -36,7 +36,7 @@
 #endif
 }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 
@@ -59,4 +59,6 @@
     static_assert ( sv.at(1) == 'B', "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.access/back.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.access/back.pass.cpp
+++ test/std/strings/string.view/string.view.access/back.pass.cpp
@@ -24,7 +24,7 @@
     return &sv.back() == s + len - 1;
     }
 
-int main () {
+int main(int, char**) {
     assert ( test ( "ABCDE", 5 ));
     assert ( test ( "a", 1 ));
 
@@ -46,4 +46,6 @@
     static_assert ( sv.back()  == 'B', "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.access/data.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.access/data.pass.cpp
+++ test/std/strings/string.view/string.view.access/data.pass.cpp
@@ -27,7 +27,7 @@
 #endif
     }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 
@@ -50,4 +50,6 @@
     static_assert( sv.data() == s, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.access/front.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.access/front.pass.cpp
+++ test/std/strings/string.view/string.view.access/front.pass.cpp
@@ -24,7 +24,7 @@
     return &sv.front() == s;
     }
 
-int main () {
+int main(int, char**) {
     assert ( test ( "ABCDE", 5 ));
     assert ( test ( "a", 1 ));
 
@@ -46,4 +46,6 @@
     static_assert ( sv.front()  == 'A', "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.access/index.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.access/index.pass.cpp
+++ test/std/strings/string.view/string.view.access/index.pass.cpp
@@ -26,7 +26,7 @@
         }
     }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 
@@ -49,4 +49,6 @@
     static_assert ( sv[1]  == 'B', "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
+++ test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
@@ -62,7 +62,7 @@
     }
 }
 
-int main () {
+int main(int, char**) {
     test1<std::string_view> ();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test1<std::u8string_view> ();
@@ -99,4 +99,6 @@
     test2 ( U"a", 1 );
     test2 ( U"", 0 );
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.capacity/empty.fail.cpp
===================================================================
--- test/std/strings/string.view/string.view.capacity/empty.fail.cpp
+++ test/std/strings/string.view/string.view.capacity/empty.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main ()
+int main(int, char**)
 {
     std::string_view c;
     c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opeq.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@
     assert((rhs == lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -65,4 +65,6 @@
     static_assert (!("abcde0" == sv2), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opeq.string_view.string.pass.cpp
@@ -25,7 +25,7 @@
     assert((rhs == lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,5 +46,7 @@
     test("abcdefghijklmnopqrst", S("abcdefghij"), false);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
     }
+
+  return 0;
 }
 
Index: test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opeq.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@
     assert((rhs == lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -58,4 +58,6 @@
     static_assert (!(sv1 == sv3), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opge.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@
     assert((rhs >= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -68,4 +68,6 @@
     static_assert (  "abcde0" >= sv2, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opge.string_view.string.pass.cpp
@@ -25,7 +25,7 @@
     assert((rhs >= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true, false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true, true);
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opge.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@
     assert((rhs >= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -61,4 +61,6 @@
     static_assert (  sv2 >= sv1,  "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opgt.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@
     assert((rhs > lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -68,4 +68,6 @@
     static_assert (  "abcde0" > sv2, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opgt.string_view.string.pass.cpp
@@ -25,7 +25,7 @@
     assert((rhs > lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghij", true, false);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false, false);
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opgt.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@
     assert((rhs > lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -61,4 +61,6 @@
     static_assert (  sv2 > sv1, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/ople.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@
     assert((rhs <= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -68,4 +68,6 @@
     static_assert (!("abcde0" <= sv2), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/ople.string_view.string.pass.cpp
@@ -25,7 +25,7 @@
     assert((rhs <= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false, true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", true, true);
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/ople.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@
     assert((rhs <= lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -61,4 +61,6 @@
     static_assert (!(sv2 <= sv1), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/oplt.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@
     assert((rhs < lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -68,4 +68,6 @@
     static_assert (!("abcde0" < sv2), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/oplt.string_view.string.pass.cpp
@@ -25,7 +25,7 @@
     assert((rhs < lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@
     test(S("abcdefghijklmnopqrst"), "abcdefghij", false, true);
     test(S("abcdefghijklmnopqrst"), "abcdefghijklmnopqrst", false, false);
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/oplt.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@
     assert((rhs < lhs) == y);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -61,4 +61,6 @@
     static_assert (!(sv2 < sv1), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opne.string_view.pointer.pass.cpp
@@ -27,7 +27,7 @@
     assert((rhs != lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -66,4 +66,6 @@
     static_assert (  "abcde0" != sv2, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opne.string_view.string.pass.cpp
@@ -25,7 +25,7 @@
     assert((rhs != lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -46,4 +46,6 @@
     test("abcdefghijklmnopqrst", S("abcdefghij"), true);
     test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), false);
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp
+++ test/std/strings/string.view/string.view.comparison/opne.string_view.string_view.pass.cpp
@@ -26,7 +26,7 @@
     assert((rhs != lhs) == x);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -58,4 +58,6 @@
     static_assert (   sv1 != sv3,  "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.cons/assign.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.cons/assign.pass.cpp
+++ test/std/strings/string.view/string.view.cons/assign.pass.cpp
@@ -29,7 +29,7 @@
     return sv0.size() == sv1.size() && sv0.data() == sv1.data();
     }
 
-int main () {
+int main(int, char**) {
 
     assert( test<std::string_view>    (  "1234"));
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -54,4 +54,6 @@
 #endif
     static_assert( test<std::wstring_view>   ({ L"abc", 3}), "");
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.cons/default.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.cons/default.pass.cpp
+++ test/std/strings/string.view/string.view.cons/default.pass.cpp
@@ -35,7 +35,7 @@
     }
 }
 
-int main () {
+int main(int, char**) {
     test<std::string_view> ();
     test<std::u16string_view> ();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -44,4 +44,6 @@
     test<std::u32string_view> ();
     test<std::wstring_view> ();
 
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
+++ test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
@@ -39,7 +39,7 @@
     }
 
 
-int main () {
+int main(int, char**) {
 
     test ( "QBCDE" );
     test ( "A" );
@@ -65,4 +65,6 @@
     static_assert ( sv1.size() == 5, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
+++ test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
@@ -31,7 +31,7 @@
     }
 }
 
-int main () {
+int main(int, char**) {
 
     test ( "QBCDE", 5 );
     test ( "QBCDE", 2 );
@@ -82,4 +82,6 @@
     }
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.cons/from_string.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.cons/from_string.pass.cpp
+++ test/std/strings/string.view/string.view.cons/from_string.pass.cpp
@@ -31,7 +31,7 @@
     assert ( sv1.data() == str.data());
 }
 
-int main () {
+int main(int, char**) {
 
     test ( std::string("QBCDE") );
     test ( std::string("") );
@@ -61,4 +61,6 @@
     test ( std::basic_string<char, dummy_char_traits>("") );
     test ( std::basic_string<char, dummy_char_traits>() );
 
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
===================================================================
--- test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
+++ test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
@@ -18,7 +18,7 @@
 
 struct dummy_char_traits : public std::char_traits<char> {};
 
-int main () {
+int main(int, char**) {
     using string_view = std::basic_string_view<char>;
     using string      = std::              basic_string     <char, dummy_char_traits>;
 
@@ -28,4 +28,6 @@
     assert ( sv1.size() == s.size());
     assert ( sv1.data() == s.data());
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.cons/from_string2.fail.cpp
===================================================================
--- test/std/strings/string.view/string.view.cons/from_string2.fail.cpp
+++ test/std/strings/string.view/string.view.cons/from_string2.fail.cpp
@@ -18,7 +18,7 @@
 
 struct dummy_char_traits : public std::char_traits<char> {};
 
-int main () {
+int main(int, char**) {
     using string_view = std::basic_string_view<char, dummy_char_traits>;
     using string      = std::              basic_string     <char>;
 
@@ -28,4 +28,6 @@
     assert ( sv1.size() == s.size());
     assert ( sv1.data() == s.data());
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp
+++ test/std/strings/string.view/string.view.cons/implicit_deduction_guides.pass.cpp
@@ -26,7 +26,7 @@
 // (2)  basic_string_view(const basic_string_view&)
 // (3)  basic_string_view(const CharT*, size_type)
 // (4)  basic_string_view(const CharT*)
-int main()
+int main(int, char**)
 {
   { // Testing (1)
     // Nothing TODO. Cannot deduce without any arguments.
@@ -61,4 +61,6 @@
     ASSERT_SAME_TYPE(decltype(w), std::wstring_view);
     assert(w == L"abcdef");
   }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_char_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_char_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_char_size.pass.cpp
@@ -35,7 +35,7 @@
         assert(0 <= x && x + 1 <= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -81,4 +81,6 @@
     static_assert (sv2.find( 'c', 4 ) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_first_not_of_char_size.pass.cpp
@@ -35,7 +35,7 @@
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -81,4 +81,6 @@
     static_assert (sv2.find_first_not_of( 'q', 5 ) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size.pass.cpp
@@ -141,7 +141,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -162,4 +162,6 @@
     static_assert (sv2.find_first_not_of( "lecar", 0) == 1, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_first_not_of_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@
     static_assert (sv2.find_first_not_of( "lecar", 0, 5) == 1, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_first_not_of_string_view_size.pass.cpp
@@ -137,11 +137,13 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
     test0<S>();
     test1<S>();
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_first_of_char_size.pass.cpp
@@ -35,7 +35,7 @@
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -79,4 +79,6 @@
     static_assert (sv2.find_first_of( 'e', 5 ) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_first_of_pointer_size.pass.cpp
@@ -141,7 +141,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -162,4 +162,6 @@
     static_assert (sv2.find_first_of( "lecar", 0) == 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_first_of_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@
     static_assert (sv2.find_first_of( "lecar", 0, 5) == 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_first_of_string_view_size.pass.cpp
@@ -137,11 +137,13 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
     test0<S>();
     test1<S>();
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_last_not_of_char_size.pass.cpp
@@ -35,7 +35,7 @@
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -79,4 +79,6 @@
     static_assert (sv2.find_last_not_of( 'e', 5 ) == 3, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size.pass.cpp
@@ -141,7 +141,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -162,4 +162,6 @@
     static_assert (sv2.find_last_not_of( "lecar", 5) == 3, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_last_not_of_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@
     static_assert (sv2.find_last_not_of( "lecar", 5, 0) == 4, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_last_not_of_string_view_size.pass.cpp
@@ -137,11 +137,13 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
     test0<S>();
     test1<S>();
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_last_of_char_size.pass.cpp
@@ -35,7 +35,7 @@
         assert(x < s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -79,4 +79,6 @@
     static_assert (sv2.find_last_of( 'e', 5 ) == 4, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_last_of_pointer_size.pass.cpp
@@ -141,7 +141,7 @@
     test(S("pniotcfrhqsmgdkjbael"), "htaobedqikfplcgjsmrn", 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -162,4 +162,6 @@
     static_assert (sv2.find_last_of( "lecar", 5) == 4, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_last_of_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@
     test(S("hnbrcplsjfgiktoedmaq"), "qprlsfojamgndekthibc", 21, 20, 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@
     static_assert (sv2.find_last_of( "lecar", 5, 5) == 4, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_last_of_string_view_size.pass.cpp
@@ -137,11 +137,13 @@
     test(S("pniotcfrhqsmgdkjbael"), S("htaobedqikfplcgjsmrn"), 19);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
     test0<S>();
     test1<S>();
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_pointer_size.pass.cpp
@@ -147,7 +147,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -168,4 +168,6 @@
     static_assert (sv2.find( "abcde", 1) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_pointer_size_size.pass.cpp
@@ -366,7 +366,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, S::npos);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -390,4 +390,6 @@
     static_assert (sv2.find( "abcde", 0, 1 ) == 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/find_string_view_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -161,4 +161,6 @@
     static_assert (sv2.find(sv2, 1 ) == SV::npos, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/rfind_char_size.pass.cpp
@@ -34,7 +34,7 @@
         assert(x + 1 <= s.size());
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -80,4 +80,6 @@
     static_assert (sv2.rfind( 'b', 4 ) == 1, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/rfind_pointer_size.pass.cpp
@@ -147,7 +147,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -168,4 +168,6 @@
     static_assert (sv2.rfind( "abcde", 1) == 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/rfind_pointer_size_size.pass.cpp
@@ -365,7 +365,7 @@
     test(S("abcdeabcdeabcdeabcde"), "abcdeabcdeabcdeabcde", 21, 20, 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -389,4 +389,6 @@
     static_assert (sv2.rfind( "abcde", 0, 1 ) == 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp
+++ test/std/strings/string.view/string.view.find/rfind_string_view_size.pass.cpp
@@ -140,7 +140,7 @@
     test(S("abcdeabcdeabcdeabcde"), S("abcdeabcdeabcdeabcde"), 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view S;
@@ -161,4 +161,6 @@
     static_assert (sv2.rfind(sv2, 1) == 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.io/stream_insert.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.io/stream_insert.pass.cpp
+++ test/std/strings/string.view/string.view.io/stream_insert.pass.cpp
@@ -20,7 +20,7 @@
 using std::string_view;
 using std::wstring_view;
 
-int main()
+int main(int, char**)
 {
     {
         std::ostringstream out;
@@ -54,4 +54,6 @@
         assert(out.good());
         assert(L"   " + s == out.str());
     }
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.iterators/begin.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.iterators/begin.pass.cpp
+++ test/std/strings/string.view/string.view.iterators/begin.pass.cpp
@@ -39,7 +39,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     typedef std::string_view    string_view;
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -90,4 +90,6 @@
     static_assert (   *wsv.cbegin() ==   wsv[0], "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.iterators/end.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.iterators/end.pass.cpp
+++ test/std/strings/string.view/string.view.iterators/end.pass.cpp
@@ -48,7 +48,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     typedef std::string_view    string_view;
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -99,4 +99,6 @@
     static_assert (   wsv.begin() !=   wsv.cend(), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
+++ test/std/strings/string.view/string.view.iterators/rbegin.pass.cpp
@@ -40,7 +40,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     typedef std::string_view    string_view;
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -91,4 +91,6 @@
     static_assert (   *wsv.crbegin() ==   wsv[2], "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.iterators/rend.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.iterators/rend.pass.cpp
+++ test/std/strings/string.view/string.view.iterators/rend.pass.cpp
@@ -48,7 +48,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     typedef std::string_view    string_view;
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
@@ -99,4 +99,6 @@
     static_assert (   *--wsv.crend() ==   wsv[0], "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
+++ test/std/strings/string.view/string.view.modifiers/remove_prefix.pass.cpp
@@ -47,7 +47,7 @@
 }
 #endif
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
     test ( "", 0 );
@@ -74,4 +74,6 @@
     static_assert ( test_ce ( 9, 3 ) == 6, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
+++ test/std/strings/string.view/string.view.modifiers/remove_suffix.pass.cpp
@@ -47,7 +47,7 @@
 }
 #endif
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
     test ( "", 0 );
@@ -74,4 +74,6 @@
     static_assert ( test_ce ( 9, 3 ) == 6, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
+++ test/std/strings/string.view/string.view.modifiers/swap.pass.cpp
@@ -46,7 +46,7 @@
 #endif
 
 
-int main () {
+int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
     test ( "", 0 );
@@ -72,4 +72,6 @@
     static_assert ( test_ce (0, 1) == 1, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp
+++ test/std/strings/string.view/string.view.nonmem/quoted.pass.cpp
@@ -160,7 +160,7 @@
     return s;
 }
 
-int main()
+int main(int, char**)
 {
     round_trip    (  "" );
     round_trip_ws (  "" );
@@ -207,7 +207,11 @@
 
     assert ( unquote (  "" ) ==  "" ); // nothing there
     assert ( unquote ( L"" ) == L"" ); // nothing there
-    }
+
+    return 0;
+}
 #else
-int main() {}
+int main(int, char**) {
+  return 0;
+}
 #endif
Index: test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
+++ test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp
@@ -32,7 +32,7 @@
     test1 ( sv1, s2, expected );
 }
 
-int main()
+int main(int, char**)
 {
     {
     test("", "", 0);
@@ -123,4 +123,6 @@
     static_assert ( sv2.compare("abcde") == 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
+++ test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp
@@ -354,7 +354,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test0();
     test1();
@@ -449,4 +449,6 @@
     static_assert ( sv2.compare(0, 6, "abcde") == 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
+++ test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp
@@ -354,7 +354,7 @@
 }
 
 
-int main () {
+int main(int, char**) {
     test0();
     test1();
     test2();
@@ -398,4 +398,6 @@
     static_assert ( sv1.compare(2, 4, sv2) == 1, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
+++ test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp
@@ -1291,7 +1291,7 @@
     }
 
 
-int main () {
+int main(int, char**) {
     test0();
     test1();
     test2();
@@ -1349,4 +1349,6 @@
     static_assert ( sv2.compare(0, 0, "abcde", 1, 0) == 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
+++ test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp
@@ -5747,7 +5747,7 @@
 }
 
 
-int main () {
+int main(int, char**) {
     test0();
     test1();
     test2();
@@ -5844,4 +5844,6 @@
     static_assert ( sv1.compare(2, 4, "abcde", 3, 4) == -1, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
+++ test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp
@@ -34,7 +34,7 @@
     test1(sv1, sv2, expected);
 }
 
-int main () {
+int main(int, char**) {
 
     test("",                     "", 0);
     test("",                     "abcde", -5);
@@ -118,4 +118,6 @@
     static_assert ( sv2.compare(sv3)  < 0, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.ops/copy.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.ops/copy.pass.cpp
+++ test/std/strings/string.view/string.view.ops/copy.pass.cpp
@@ -77,7 +77,7 @@
 
 }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( "ABCDE");
     test ( "a" );
@@ -99,4 +99,6 @@
     test ( U"a" );
     test ( U"" );
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.ops/substr.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.ops/substr.pass.cpp
+++ test/std/strings/string.view/string.view.ops/substr.pass.cpp
@@ -69,7 +69,7 @@
     test1(sv1, sv1.size() + 1, string_view_t::npos);
 }
 
-int main () {
+int main(int, char**) {
     test ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( "ABCDE");
     test ( "a" );
@@ -117,4 +117,6 @@
     }
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp
+++ test/std/strings/string.view/string.view.synop/nothing_to_do.pass.cpp
@@ -8,4 +8,6 @@
 
 #include <string_view>
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
+++ test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -43,4 +43,6 @@
     static_assert (!sv2.ends_with('x'), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
+++ test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -100,4 +100,6 @@
     static_assert ( svNot.ends_with("def"), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
+++ test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -100,4 +100,6 @@
     static_assert ( svNot.ends_with(svNot), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp
+++ test/std/strings/string.view/string.view.template/nothing_to_do.pass.cpp
@@ -8,4 +8,6 @@
 
 #include <string_view>
 
-int main () {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
+++ test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -43,4 +43,6 @@
     static_assert (!sv2.starts_with('x'), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
+++ test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -100,4 +100,6 @@
     static_assert ( svNot.starts_with("def"), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
===================================================================
--- test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
+++ test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "constexpr_char_traits.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::string_view SV;
@@ -100,4 +100,6 @@
     static_assert ( svNot.starts_with(svNot), "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/strings/string.view/string_view.literals/literal.pass.cpp
===================================================================
--- test/std/strings/string.view/string_view.literals/literal.pass.cpp
+++ test/std/strings/string.view/string_view.literals/literal.pass.cpp
@@ -23,7 +23,7 @@
     typedef std::string_view   u8string_view;
 #endif
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::string_view_literals;
 
@@ -69,4 +69,6 @@
     static_assert(noexcept( L"ABC"sv), "");
     static_assert(noexcept( u"ABC"sv), "");
     static_assert(noexcept( U"ABC"sv), "");
+
+  return 0;
 }
Index: test/std/strings/string.view/string_view.literals/literal1.fail.cpp
===================================================================
--- test/std/strings/string.view/string_view.literals/literal1.fail.cpp
+++ test/std/strings/string.view/string_view.literals/literal1.fail.cpp
@@ -14,9 +14,11 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using std::string_view;
 
     string_view foo  =   ""sv;  // should fail w/conversion operator not found
+
+  return 0;
 }
Index: test/std/strings/string.view/string_view.literals/literal1.pass.cpp
===================================================================
--- test/std/strings/string.view/string_view.literals/literal1.pass.cpp
+++ test/std/strings/string.view/string_view.literals/literal1.pass.cpp
@@ -15,10 +15,12 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals;
 
     std::string_view foo  =   ""sv;
     assert(foo.length() == 0);
+
+  return 0;
 }
Index: test/std/strings/string.view/string_view.literals/literal2.fail.cpp
===================================================================
--- test/std/strings/string.view/string_view.literals/literal2.fail.cpp
+++ test/std/strings/string.view/string_view.literals/literal2.fail.cpp
@@ -14,7 +14,9 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::string_view foo  =   ""sv;  // should fail w/conversion operator not found
+
+  return 0;
 }
Index: test/std/strings/string.view/string_view.literals/literal2.pass.cpp
===================================================================
--- test/std/strings/string.view/string_view.literals/literal2.pass.cpp
+++ test/std/strings/string.view/string_view.literals/literal2.pass.cpp
@@ -15,10 +15,12 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::string_view_literals;
 
     std::string_view foo  =   ""sv;
     assert(foo.length() == 0);
+
+  return 0;
 }
Index: test/std/strings/string.view/string_view.literals/literal3.pass.cpp
===================================================================
--- test/std/strings/string.view/string_view.literals/literal3.pass.cpp
+++ test/std/strings/string.view/string_view.literals/literal3.pass.cpp
@@ -15,10 +15,12 @@
 #include <string_view>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std;
 
     string_view foo  =   ""sv;
     assert(foo.length() == 0);
+
+  return 0;
 }
Index: test/std/strings/string.view/traits_mismatch.fail.cpp
===================================================================
--- test/std/strings/string.view/traits_mismatch.fail.cpp
+++ test/std/strings/string.view/traits_mismatch.fail.cpp
@@ -11,7 +11,9 @@
 
 #include <string_view>
 
-int main()
+int main(int, char**)
 {
     std::basic_string_view<char, std::char_traits<wchar_t>> s;
+
+  return 0;
 }
Index: test/std/strings/string.view/types.pass.cpp
===================================================================
--- test/std/strings/string.view/types.pass.cpp
+++ test/std/strings/string.view/types.pass.cpp
@@ -67,7 +67,7 @@
     static_assert((std::is_same<typename S::reverse_iterator, typename S::const_reverse_iterator>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::char_traits<char> >();
     test<std::char_traits<wchar_t> >();
@@ -76,4 +76,6 @@
 #endif
     static_assert((std::is_same<std::basic_string_view<char>::traits_type,
                                 std::char_traits<char> >::value), "");
+
+  return 0;
 }
Index: test/std/strings/strings.erasure/erase.pass.cpp
===================================================================
--- test/std/strings/strings.erasure/erase.pass.cpp
+++ test/std/strings/strings.erasure/erase.pass.cpp
@@ -67,9 +67,11 @@
     test0(S("aba"), opt('c'), S("aba"));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::string>();
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
+
+  return 0;
 }
Index: test/std/strings/strings.erasure/erase_if.pass.cpp
===================================================================
--- test/std/strings/strings.erasure/erase_if.pass.cpp
+++ test/std/strings/strings.erasure/erase_if.pass.cpp
@@ -67,9 +67,11 @@
     test0(S("aba"), True,   S(""));
 }
 
-int main()
+int main(int, char**)
 {
     test<std::string>();
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
+
+  return 0;
 }
Index: test/std/strings/strings.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/strings/strings.general/nothing_to_do.pass.cpp
+++ test/std/strings/strings.general/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/futures/futures.async/async.fail.cpp
===================================================================
--- test/std/thread/futures/futures.async/async.fail.cpp
+++ test/std/thread/futures/futures.async/async.fail.cpp
@@ -30,8 +30,10 @@
 
 int foo (int x) { return x; }
 
-int main ()
+int main(int, char**)
 {
     std::async(                    foo, 3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::async(std::launch::async, foo, 3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/thread/futures/futures.async/async.pass.cpp
===================================================================
--- test/std/thread/futures/futures.async/async.pass.cpp
+++ test/std/thread/futures/futures.async/async.pass.cpp
@@ -102,7 +102,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     // The default launch policy is implementation defined. libc++ defines
     // it to be std::launch::async.
@@ -151,4 +151,5 @@
         try { f.get(); assert (false); } catch ( int ) {}
     }
 #endif
+    return 0;
 }
Index: test/std/thread/futures/futures.async/async_race.38682.pass.cpp
===================================================================
--- test/std/thread/futures/futures.async/async_race.38682.pass.cpp
+++ test/std/thread/futures/futures.async/async_race.38682.pass.cpp
@@ -38,7 +38,7 @@
 
 static void worker_void() { }
 
-int main() {
+int main(int, char**) {
   // future<T>
   {
     std::vector<int> const v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
@@ -65,4 +65,6 @@
       fut.get();
     }
   }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.async/async_race.pass.cpp
===================================================================
--- test/std/thread/futures/futures.async/async_race.pass.cpp
+++ test/std/thread/futures/futures.async/async_race.pass.cpp
@@ -62,6 +62,8 @@
     }
 }
 
-int main() {
+int main(int, char**) {
     for (int i=0; i < 25; ++i) test_each();
+
+  return 0;
 }
Index: test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
===================================================================
--- test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
+++ test/std/thread/futures/futures.errors/default_error_condition.pass.cpp
@@ -17,10 +17,12 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::future_category();
     std::error_condition e_cond = e_cat.default_error_condition(static_cast<int>(std::errc::not_a_directory));
     assert(e_cond.category() == e_cat);
     assert(e_cond.value() == static_cast<int>(std::errc::not_a_directory));
+
+  return 0;
 }
Index: test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
===================================================================
--- test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
+++ test/std/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp
@@ -17,9 +17,11 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::future_category();
     assert(e_cat.equivalent(std::error_code(5, e_cat), 5));
     assert(!e_cat.equivalent(std::error_code(5, e_cat), 6));
+
+  return 0;
 }
Index: test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
===================================================================
--- test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
+++ test/std/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp
@@ -17,10 +17,12 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& e_cat = std::future_category();
     std::error_condition e_cond = e_cat.default_error_condition(5);
     assert(e_cat.equivalent(5, e_cond));
     assert(!e_cat.equivalent(6, e_cond));
+
+  return 0;
 }
Index: test/std/thread/futures/futures.errors/future_category.pass.cpp
===================================================================
--- test/std/thread/futures/futures.errors/future_category.pass.cpp
+++ test/std/thread/futures/futures.errors/future_category.pass.cpp
@@ -16,8 +16,10 @@
 #include <cstring>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::error_category& ec = std::future_category();
     assert(std::strcmp(ec.name(), "future") == 0);
+
+  return 0;
 }
Index: test/std/thread/futures/futures.errors/make_error_code.pass.cpp
===================================================================
--- test/std/thread/futures/futures.errors/make_error_code.pass.cpp
+++ test/std/thread/futures/futures.errors/make_error_code.pass.cpp
@@ -17,11 +17,13 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec = make_error_code(std::future_errc::broken_promise);
         assert(ec.value() == static_cast<int>(std::future_errc::broken_promise));
         assert(ec.category() == std::future_category());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.errors/make_error_condition.pass.cpp
===================================================================
--- test/std/thread/futures/futures.errors/make_error_condition.pass.cpp
+++ test/std/thread/futures/futures.errors/make_error_condition.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         const std::error_condition ec1 =
@@ -26,4 +26,6 @@
                   static_cast<int>(std::future_errc::future_already_retrieved));
         assert(ec1.category() == std::future_category());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.future_error/code.pass.cpp
===================================================================
--- test/std/thread/futures/futures.future_error/code.pass.cpp
+++ test/std/thread/futures/futures.future_error/code.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::error_code ec = std::make_error_code(std::future_errc::broken_promise);
@@ -53,4 +53,6 @@
         assert(f.code() == std::make_error_code(std::future_errc::no_state));
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.future_error/types.pass.cpp
===================================================================
--- test/std/thread/futures/futures.future_error/types.pass.cpp
+++ test/std/thread/futures/futures.future_error/types.pass.cpp
@@ -15,8 +15,10 @@
 #include <future>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_convertible<std::future_error*,
                                        std::logic_error*>::value), "");
+
+  return 0;
 }
Index: test/std/thread/futures/futures.future_error/what.pass.cpp
===================================================================
--- test/std/thread/futures/futures.future_error/what.pass.cpp
+++ test/std/thread/futures/futures.future_error/what.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::future_error f(std::make_error_code(std::future_errc::broken_promise));
@@ -50,4 +50,6 @@
         LIBCPP_ASSERT(std::strcmp(f.what(), "Operation not permitted on an object without "
                       "an associated state.") == 0);
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.overview/future_errc.pass.cpp
===================================================================
--- test/std/thread/futures/futures.overview/future_errc.pass.cpp
+++ test/std/thread/futures/futures.overview/future_errc.pass.cpp
@@ -23,7 +23,7 @@
 
 #include <future>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::future_errc::broken_promise != std::future_errc::future_already_retrieved, "");
     static_assert(std::future_errc::broken_promise != std::future_errc::promise_already_satisfied, "");
@@ -36,4 +36,6 @@
     static_assert(std::future_errc::future_already_retrieved != static_cast<std::future_errc>(0), "");
     static_assert(std::future_errc::promise_already_satisfied != static_cast<std::future_errc>(0), "");
     static_assert(std::future_errc::no_state != static_cast<std::future_errc>(0), "");
+
+  return 0;
 }
Index: test/std/thread/futures/futures.overview/future_status.pass.cpp
===================================================================
--- test/std/thread/futures/futures.overview/future_status.pass.cpp
+++ test/std/thread/futures/futures.overview/future_status.pass.cpp
@@ -19,9 +19,11 @@
 
 #include <future>
 
-int main()
+int main(int, char**)
 {
     static_assert(static_cast<int>(std::future_status::ready) == 0, "");
     static_assert(static_cast<int>(std::future_status::timeout) == 1, "");
     static_assert(static_cast<int>(std::future_status::deferred) == 2, "");
+
+  return 0;
 }
Index: test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp
===================================================================
--- test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp
+++ test/std/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp
@@ -15,10 +15,12 @@
 #include <future>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_error_code_enum  <std::future_errc>::value, "");
 #if TEST_STD_VER > 14
     static_assert(std::is_error_code_enum_v<std::future_errc>, "");
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.overview/launch.pass.cpp
===================================================================
--- test/std/thread/futures/futures.overview/launch.pass.cpp
+++ test/std/thread/futures/futures.overview/launch.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
    LIBCPP_STATIC_ASSERT(static_cast<int>(std::launch::any) ==
@@ -43,4 +43,6 @@
 #endif
     static_assert(static_cast<int>(std::launch::async) == 1, "");
     static_assert(static_cast<int>(std::launch::deferred) == 2, "");
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
+++ test/std/thread/futures/futures.promise/alloc_ctor.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -81,4 +81,6 @@
         std::future<void> f = p.get_future();
         assert(f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/copy_assign.fail.cpp
===================================================================
--- test/std/thread/futures/futures.promise/copy_assign.fail.cpp
+++ test/std/thread/futures/futures.promise/copy_assign.fail.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -47,4 +47,6 @@
         p = p0; // expected-error {{'operator=' is a private member of 'std::__1::promise<void>'}}
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
===================================================================
--- test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
+++ test/std/thread/futures/futures.promise/copy_ctor.fail.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -47,4 +47,6 @@
         std::promise<void> p(p0); // expected-error {{calling a private constructor of class 'std::__1::promise<void>'}}
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/default.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/default.pass.cpp
+++ test/std/thread/futures/futures.promise/default.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<int> p;
@@ -35,4 +35,6 @@
         std::future<void> f = p.get_future();
         assert(f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/dtor.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/dtor.pass.cpp
+++ test/std/thread/futures/futures.promise/dtor.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -123,4 +123,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/get_future.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/get_future.pass.cpp
+++ test/std/thread/futures/futures.promise/get_future.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<double> p;
@@ -56,4 +56,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/move_assign.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/move_assign.pass.cpp
+++ test/std/thread/futures/futures.promise/move_assign.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -93,4 +93,6 @@
         assert(test_alloc_base::alloc_count == 1);
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/move_ctor.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/move_ctor.pass.cpp
+++ test/std/thread/futures/futures.promise/move_ctor.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -87,4 +87,6 @@
 #endif
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_exception.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_exception.pass.cpp
+++ test/std/thread/futures/futures.promise/set_exception.pass.cpp
@@ -19,7 +19,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -45,4 +45,6 @@
             assert(e.code() == make_error_code(std::future_errc::promise_already_satisfied));
         }
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
+++ test/std/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp
@@ -24,7 +24,7 @@
     p.set_exception_at_thread_exit(std::make_exception_ptr(3));
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -41,4 +41,6 @@
             assert(i == 3);
         }
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
+++ test/std/thread/futures/futures.promise/set_lvalue.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int& T;
@@ -44,4 +44,6 @@
         }
 #endif
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
+++ test/std/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp
@@ -27,7 +27,7 @@
     i = 4;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<int&> p;
@@ -35,4 +35,6 @@
         std::thread(func, std::move(p)).detach();
         assert(f.get() == 4);
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
+++ test/std/thread/futures/futures.promise/set_rvalue.pass.cpp
@@ -26,7 +26,7 @@
     A(A&&) {throw 9;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::unique_ptr<int> T;
@@ -60,4 +60,6 @@
             assert(j == 9);
         }
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp
+++ test/std/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp
@@ -23,7 +23,7 @@
     p.set_value_at_thread_exit(std::unique_ptr<int>(new int(5)));
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<std::unique_ptr<int>> p;
@@ -31,4 +31,6 @@
         std::thread(func, std::move(p)).detach();
         assert(*f.get() == 5);
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
+++ test/std/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp
@@ -24,7 +24,7 @@
     p.set_value_at_thread_exit(i);
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<int> p;
@@ -32,4 +32,6 @@
         std::thread(func, std::move(p)).detach();
         assert(f.get() == 5);
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
+++ test/std/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp
@@ -27,7 +27,7 @@
     i = 1;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::promise<void> p;
@@ -36,4 +36,6 @@
         f.get();
         assert(i == 1);
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_value_const.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_value_const.pass.cpp
+++ test/std/thread/futures/futures.promise/set_value_const.pass.cpp
@@ -28,7 +28,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -68,4 +68,6 @@
         }
 #endif
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/set_value_void.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/set_value_void.pass.cpp
+++ test/std/thread/futures/futures.promise/set_value_void.pass.cpp
@@ -19,7 +19,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef void T;
@@ -37,4 +37,6 @@
             assert(e.code() == make_error_code(std::future_errc::promise_already_satisfied));
         }
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/swap.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/swap.pass.cpp
+++ test/std/thread/futures/futures.promise/swap.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -81,4 +81,6 @@
         assert(test_alloc_base::alloc_count == 1);
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
Index: test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
===================================================================
--- test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
+++ test/std/thread/futures/futures.promise/uses_allocator.pass.cpp
@@ -19,9 +19,11 @@
 #include <future>
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::uses_allocator<std::promise<int>, test_allocator<int> >::value), "");
     static_assert((std::uses_allocator<std::promise<int&>, test_allocator<int> >::value), "");
     static_assert((std::uses_allocator<std::promise<void>, test_allocator<void> >::value), "");
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp
+++ test/std/thread/futures/futures.shared_future/copy_assign.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -77,4 +77,6 @@
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp
+++ test/std/thread/futures/futures.shared_future/copy_ctor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -71,4 +71,6 @@
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp
+++ test/std/thread/futures/futures.shared_future/ctor_future.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -65,4 +65,6 @@
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/default.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/default.pass.cpp
+++ test/std/thread/futures/futures.shared_future/default.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_future<int> f;
@@ -31,4 +31,6 @@
         std::shared_future<void> f;
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/dtor.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/dtor.pass.cpp
+++ test/std/thread/futures/futures.shared_future/dtor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -66,4 +66,6 @@
         assert(f.valid());
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/get.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/get.pass.cpp
+++ test/std/thread/futures/futures.shared_future/get.pass.cpp
@@ -61,7 +61,7 @@
     p.set_exception(std::make_exception_ptr('c'));
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -150,4 +150,6 @@
         }
 #endif
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/move_assign.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/move_assign.pass.cpp
+++ test/std/thread/futures/futures.shared_future/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -71,4 +71,6 @@
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp
+++ test/std/thread/futures/futures.shared_future/move_ctor.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -65,4 +65,6 @@
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/wait.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/wait.pass.cpp
+++ test/std/thread/futures/futures.shared_future/wait.pass.cpp
@@ -39,7 +39,7 @@
     p.set_value();
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     typedef std::chrono::duration<double, std::milli> ms;
@@ -85,4 +85,6 @@
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/wait_for.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/wait_for.pass.cpp
+++ test/std/thread/futures/futures.shared_future/wait_for.pass.cpp
@@ -43,7 +43,7 @@
     p.set_value();
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     {
@@ -94,4 +94,6 @@
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
===================================================================
--- test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
+++ test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
@@ -62,7 +62,7 @@
     set_worker_thread_state(WorkerThreadState::Exiting);
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     {
@@ -128,4 +128,6 @@
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.state/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/futures/futures.state/nothing_to_do.pass.cpp
+++ test/std/thread/futures/futures.state/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/assign_copy.fail.cpp
@@ -17,10 +17,12 @@
 
 #include <future>
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0, p;
         p = p0; // expected-error {{overload resolution selected deleted operator '='}}
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/assign_move.pass.cpp
@@ -28,7 +28,7 @@
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
@@ -47,4 +47,6 @@
         assert(!p0.valid());
         assert(!p.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/ctor1.fail.cpp
@@ -25,11 +25,13 @@
 typedef volatile std::packaged_task<A(int, char)> VPT;
 
 
-int main()
+int main(int, char**)
 {
     VPT init{};
     auto const& c_init = init;
     PT p1{init}; // expected-error {{no matching constructor}}
     PT p2{c_init}; // expected-error {{no matching constructor}}
     PT p3{std::move(init)}; // expected-error {{no matching constructor for initialization of 'PT' (aka 'packaged_task<A (int, char)>')}}
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
@@ -26,8 +26,10 @@
 typedef std::packaged_task<A(int, char)> PT;
 typedef volatile std::packaged_task<A(int, char)> VPT;
 
-int main()
+int main(int, char**)
 {
     PT p { std::allocator_arg_t{}, test_allocator<A>{}, VPT {}}; // expected-error {{no matching constructor for initialization of 'PT' (aka 'packaged_task<A (int, char)>')}}
     // expected-note-re@future:* 1 {{candidate template ignored: {{(disabled by 'enable_if')|(requirement '.*' was not satisfied)}}}}
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/ctor_copy.fail.cpp
@@ -18,10 +18,12 @@
 #include <future>
 
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0;
         std::packaged_task<double(int, char)> p(p0); // expected-error {{call to deleted constructor of 'std::packaged_task<double (int, char)>'}}
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/ctor_default.pass.cpp
@@ -20,8 +20,10 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     std::packaged_task<A(int, char)> p;
     assert(!p.valid());
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/ctor_func.pass.cpp
@@ -39,7 +39,7 @@
 
 int func(int i) { return i; }
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -76,4 +76,6 @@
         p(4);
         assert(f.get() == 4);
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
@@ -44,7 +44,7 @@
 
 int func(int i) { return i; }
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(std::allocator_arg,
@@ -123,4 +123,6 @@
     }
     A::n_copies = 0;
     A::n_moves  = 0;
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/ctor_move.pass.cpp
@@ -28,7 +28,7 @@
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
@@ -45,4 +45,6 @@
         assert(!p0.valid());
         assert(!p.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/dtor.pass.cpp
@@ -39,7 +39,7 @@
     p(3, 'a');
 }
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
@@ -64,4 +64,6 @@
         std::thread(func2, std::move(p)).detach();
         assert(f.get() == 105.0);
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/get_future.pass.cpp
@@ -30,7 +30,7 @@
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -65,4 +65,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/make_ready_at_thread_exit.pass.cpp
@@ -80,7 +80,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -115,4 +115,6 @@
         t.join();
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/operator.pass.cpp
@@ -80,7 +80,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -116,4 +116,6 @@
         t.join();
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/reset.pass.cpp
@@ -33,7 +33,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p(A(5));
@@ -59,4 +59,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.members/swap.pass.cpp
@@ -28,7 +28,7 @@
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
@@ -47,4 +47,6 @@
         assert(!p0.valid());
         assert(!p.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.nonmembers/swap.pass.cpp
@@ -30,7 +30,7 @@
     long operator()(long i, long j) const {return data_ + i + j;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::packaged_task<double(int, char)> p0(A(5));
@@ -49,4 +49,6 @@
         assert(!p0.valid());
         assert(!p.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
===================================================================
--- test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
+++ test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
@@ -27,7 +27,9 @@
 #include <future>
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::uses_allocator<std::packaged_task<double(int, char)>, test_allocator<int> >::value), "");
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
+++ test/std/thread/futures/futures.unique_future/copy_assign.fail.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -47,4 +47,6 @@
         f = f0; // expected-error {{'operator=' is a private member of 'std::__1::future<void>'}}
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
+++ test/std/thread/futures/futures.unique_future/copy_ctor.fail.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -47,4 +47,6 @@
         std::future<void> f = f0; // expected-error {{calling a private constructor of class 'std::__1::future<void>'}}
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/default.pass.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/default.pass.cpp
+++ test/std/thread/futures/futures.unique_future/default.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::future<int> f;
@@ -31,4 +31,6 @@
         std::future<void> f;
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/dtor.pass.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/dtor.pass.cpp
+++ test/std/thread/futures/futures.unique_future/dtor.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_allocator.h"
 
-int main()
+int main(int, char**)
 {
     assert(test_alloc_base::alloc_count == 0);
     {
@@ -66,4 +66,6 @@
         assert(f.valid());
     }
     assert(test_alloc_base::alloc_count == 0);
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/get.pass.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/get.pass.cpp
+++ test/std/thread/futures/futures.unique_future/get.pass.cpp
@@ -61,7 +61,7 @@
     p.set_exception(std::make_exception_ptr('c'));
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -150,4 +150,6 @@
         }
 #endif
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/move_assign.pass.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/move_assign.pass.cpp
+++ test/std/thread/futures/futures.unique_future/move_assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -70,4 +70,6 @@
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp
+++ test/std/thread/futures/futures.unique_future/move_ctor.pass.cpp
@@ -17,7 +17,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/share.pass.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/share.pass.cpp
+++ test/std/thread/futures/futures.unique_future/share.pass.cpp
@@ -18,7 +18,7 @@
 #include <future>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -71,4 +71,6 @@
         assert(!f0.valid());
         assert(!f.valid());
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/wait.pass.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/wait.pass.cpp
+++ test/std/thread/futures/futures.unique_future/wait.pass.cpp
@@ -39,7 +39,7 @@
     p.set_value();
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     typedef std::chrono::duration<double, std::milli> ms;
@@ -85,4 +85,6 @@
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/wait_for.pass.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/wait_for.pass.cpp
+++ test/std/thread/futures/futures.unique_future/wait_for.pass.cpp
@@ -43,7 +43,7 @@
     p.set_value();
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     {
@@ -94,4 +94,6 @@
         assert(f.valid());
         assert(t1-t0 < ms(50));
     }
+
+  return 0;
 }
Index: test/std/thread/futures/futures.unique_future/wait_until.pass.cpp
===================================================================
--- test/std/thread/futures/futures.unique_future/wait_until.pass.cpp
+++ test/std/thread/futures/futures.unique_future/wait_until.pass.cpp
@@ -60,7 +60,7 @@
     set_worker_thread_state(WorkerThreadState::Exiting);
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock Clock;
     {
@@ -126,4 +126,6 @@
         assert(f.valid());
         assert(t1-t0 < ms(5));
     }
+
+  return 0;
 }
Index: test/std/thread/macro.pass.cpp
===================================================================
--- test/std/thread/macro.pass.cpp
+++ test/std/thread/macro.pass.cpp
@@ -14,9 +14,11 @@
 
 #include <thread>
 
-int main()
+int main(int, char**)
 {
 #ifndef __STDCPP_THREADS__
 #error __STDCPP_THREADS__ is not defined
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.condition/cv_status.pass.cpp
===================================================================
--- test/std/thread/thread.condition/cv_status.pass.cpp
+++ test/std/thread/thread.condition/cv_status.pass.cpp
@@ -15,8 +15,10 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(static_cast<int>(std::cv_status::no_timeout) == 0);
     assert(static_cast<int>(std::cv_status::timeout)    == 1);
+
+  return 0;
 }
Index: test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
===================================================================
--- test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
+++ test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
@@ -36,7 +36,7 @@
     std::this_thread::sleep_for(ms(300));
 }
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> lk(mut);
     std::thread t(func);
@@ -45,4 +45,6 @@
     Clock::time_point t1 = Clock::now();
     assert(t1-t0 > ms(250));
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/assign.fail.cpp
@@ -15,9 +15,11 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable cv0;
     std::condition_variable cv1;
     cv1 = cv0;
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/copy.fail.cpp
@@ -15,8 +15,10 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable cv0;
     std::condition_variable cv1(cv0);
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/default.pass.cpp
@@ -17,7 +17,9 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable cv;
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp
@@ -43,7 +43,7 @@
         cv->wait(lk);
 }
 
-int main()
+int main(int, char**)
 {
     cv = new std::condition_variable;
     std::thread th2(g);
@@ -54,4 +54,6 @@
     std::thread th1(f);
     th1.join();
     th2.join();
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp
@@ -46,7 +46,7 @@
     test2 = 2;
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t1(f1);
     std::thread t2(f2);
@@ -65,4 +65,6 @@
     t2.join();
     assert(test1 == 2);
     assert(test2 == 2);
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
@@ -47,7 +47,7 @@
     test2 = 2;
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t1(f1);
     std::thread t2(f2);
@@ -95,4 +95,6 @@
     }
     else
         assert(false);
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/wait.pass.cpp
@@ -36,7 +36,7 @@
     assert(test2 != 0);
 }
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex>lk(mut);
     std::thread t(f);
@@ -48,4 +48,6 @@
     lk.unlock();
     cv.notify_one();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp
@@ -59,7 +59,7 @@
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_lock<std::mutex>lk(mut);
@@ -85,4 +85,6 @@
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp
@@ -66,7 +66,7 @@
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_lock<std::mutex>lk(mut);
@@ -92,4 +92,6 @@
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp
@@ -46,7 +46,7 @@
     assert(test2 != 0);
 }
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex>lk(mut);
     std::thread t(f);
@@ -58,4 +58,6 @@
     lk.unlock();
     cv.notify_one();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp
@@ -72,7 +72,7 @@
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_lock<std::mutex>lk(mut);
@@ -98,4 +98,6 @@
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp
@@ -85,7 +85,7 @@
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_lock<std::mutex>lk(mut);
@@ -111,4 +111,6 @@
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/assign.fail.cpp
@@ -15,9 +15,11 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable_any cv0;
     std::condition_variable_any cv1;
     cv1 = cv0;
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/copy.fail.cpp
@@ -15,8 +15,10 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable_any cv0;
     std::condition_variable_any cv1(cv0);
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/default.pass.cpp
@@ -17,7 +17,9 @@
 #include <condition_variable>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::condition_variable_any cv;
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp
@@ -44,7 +44,7 @@
     m.unlock();
 }
 
-int main()
+int main(int, char**)
 {
     cv = new std::condition_variable_any;
     std::thread th2(g);
@@ -55,4 +55,6 @@
     std::thread th1(f);
     th1.join();
     th2.join();
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp
@@ -50,7 +50,7 @@
     test2 = 2;
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t1(f1);
     std::thread t2(f2);
@@ -69,4 +69,6 @@
     t2.join();
     assert(test1 == 2);
     assert(test2 == 2);
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp
@@ -52,7 +52,7 @@
     test2 = 2;
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t1(f1);
     std::thread t2(f2);
@@ -96,4 +96,6 @@
     }
     else
         assert(false);
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp
@@ -41,7 +41,7 @@
     assert(test2 != 0);
 }
 
-int main()
+int main(int, char**)
 {
     L1 lk(m0);
     std::thread t(f);
@@ -53,4 +53,6 @@
     lk.unlock();
     cv.notify_one();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp
@@ -62,7 +62,7 @@
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         L1 lk(m0);
@@ -88,4 +88,6 @@
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp
@@ -70,7 +70,7 @@
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         expect_result = true;
@@ -98,4 +98,6 @@
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp
@@ -50,7 +50,7 @@
     assert(test2 != 0);
 }
 
-int main()
+int main(int, char**)
 {
     L1 lk(m0);
     std::thread t(f);
@@ -62,4 +62,6 @@
     lk.unlock();
     cv.notify_one();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
@@ -109,7 +109,7 @@
 typedef std::chrono::system_clock Clock;
 typedef std::chrono::milliseconds MS;
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
   assert(argc == 2);
   int id = std::stoi(argv[1]);
   assert(id >= 1 && id <= 6);
@@ -130,4 +130,6 @@
     }
   } catch (...) {}
   assert(false);
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp
@@ -75,7 +75,7 @@
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         L1 lk(m0);
@@ -101,4 +101,6 @@
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
===================================================================
--- test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
+++ test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp
@@ -89,7 +89,7 @@
     ++runs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         L1 lk(m0);
@@ -115,4 +115,6 @@
         lk.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.general/nothing_to_do.pass.cpp
+++ test/std/thread/thread.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp
@@ -92,7 +92,7 @@
     bool locked() const {return locked_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         L0 l0;
@@ -518,4 +518,6 @@
     }
 #endif  // TEST_HAS_NO_EXCEPTIONS
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
@@ -72,7 +72,7 @@
     bool locked() const {return locked_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         L0 l0;
@@ -522,4 +522,6 @@
         assert(!l3.locked());
     }
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp
@@ -42,11 +42,13 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.guard/assign.fail.cpp
@@ -14,11 +14,13 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m0;
     std::mutex m1;
     std::lock_guard<std::mutex> lg0(m0);
     std::lock_guard<std::mutex> lg(m1);
     lg = lg0;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.guard/copy.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m;
     std::lock_guard<std::mutex> lg0(m);
     std::lock_guard<std::mutex> lg(lg0);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp
@@ -16,8 +16,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m;
     std::lock_guard<std::mutex> lg = m; // expected-error{{no viable conversion}}
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp
@@ -46,7 +46,7 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
@@ -58,4 +58,6 @@
     std::lock_guard lg(m);
     static_assert((std::is_same<decltype(lg), std::lock_guard<decltype(m)>>::value), "" );
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp
@@ -21,8 +21,10 @@
 #include <mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::lock_guard<std::mutex>::mutex_type,
                    std::mutex>::value), "");
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/adopt_lock.pass.cpp
@@ -31,7 +31,7 @@
     TestMutex& operator=(TestMutex const&) = delete;
 };
 
-int main()
+int main(int, char**)
 {
     {
         using LG = std::scoped_lock<>;
@@ -68,4 +68,6 @@
         assert(!m1.locked && !m2.locked && !m3.locked);
     }
 
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/assign.fail.cpp
@@ -18,7 +18,7 @@
 #include <mutex>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using M = std::mutex;
     M m0, m1, m2;
@@ -46,4 +46,6 @@
         LG lg2(om0, om1, om2);
         lg1 = lg2; // expected-error{{overload resolution selected deleted operator '='}}
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/copy.fail.cpp
@@ -18,7 +18,7 @@
 #include <mutex>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using M = std::mutex;
     M m0, m1, m2;
@@ -42,4 +42,6 @@
         const LG Orig(m0, m1, m2);
         LG Copy(Orig); // expected-error{{call to deleted constructor of 'LG'}}
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.fail.cpp
@@ -21,7 +21,7 @@
 template <class LG>
 void test_conversion(LG) {}
 
-int main()
+int main(int, char**)
 {
     using M = std::mutex;
     M m0, m1, m2;
@@ -49,4 +49,6 @@
         LG lg = {m0, m1, m2}; // expected-error{{chosen constructor is explicit in copy-initialization}}
         test_conversion<LG>({n0, n1, n2}); // expected-error{{no matching function for call}}
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/mutex.pass.cpp
@@ -61,7 +61,7 @@
 };
 #endif // !defined(TEST_HAS_NO_EXCEPTIONS)
 
-int main()
+int main(int, char**)
 {
     {
         using LG = std::scoped_lock<>;
@@ -151,4 +151,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/types.pass.cpp
@@ -36,7 +36,7 @@
     return !std::is_same<decltype(test_typedef<LG>(0)), NAT>::value;
 }
 
-int main()
+int main(int, char**)
 {
     {
         using T = std::scoped_lock<>;
@@ -74,4 +74,6 @@
         using T = std::scoped_lock<M1, M1, M1>;
         static_assert(!has_mutex_type<T>(), "");
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp
@@ -18,9 +18,11 @@
 std::shared_timed_mutex m0;
 std::shared_timed_mutex m1;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0(m0);
     std::shared_lock<std::shared_timed_mutex> lk1(m1);
     lk1 = lk0;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp
@@ -17,8 +17,10 @@
 
 std::shared_timed_mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0(m);
     std::shared_lock<std::shared_timed_mutex> lk = lk0;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp
@@ -18,9 +18,11 @@
 #include <shared_mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> ul;
     assert(!ul.owns_lock());
     assert(ul.mutex() == nullptr);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
@@ -20,7 +20,7 @@
 #include "nasty_containers.hpp"
 
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;
@@ -46,4 +46,6 @@
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;
@@ -41,4 +41,6 @@
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp
@@ -71,7 +71,7 @@
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     std::vector<std::thread> v;
     {
@@ -99,4 +99,6 @@
     std::shared_lock sl(m);
     static_assert((std::is_same<decltype(sl), std::shared_lock<decltype(m)>>::value), "" );
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;
@@ -37,4 +37,6 @@
     assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp
@@ -19,7 +19,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;
@@ -35,4 +35,6 @@
     assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == false);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp
@@ -66,7 +66,7 @@
     assert(d < Tolerance);  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -88,4 +88,6 @@
         for (auto& t : v)
             t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp
@@ -65,7 +65,7 @@
     assert(d < Tolerance);  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -87,4 +87,6 @@
         for (auto& t : v)
             t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp
@@ -57,7 +57,7 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -67,4 +67,6 @@
     m.unlock();
     for (auto& t : v)
         t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp
@@ -80,7 +80,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -90,4 +90,6 @@
     m.unlock();
     for (auto& t : v)
         t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
@@ -34,7 +34,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
@@ -67,4 +67,6 @@
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
@@ -39,7 +39,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
@@ -72,4 +72,6 @@
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
@@ -38,7 +38,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::steady_clock Clock;
     std::shared_lock<mutex> lk(m, std::defer_lock);
@@ -72,4 +72,6 @@
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp
@@ -30,7 +30,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk(m);
     lk.unlock();
@@ -59,4 +59,6 @@
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp
@@ -26,7 +26,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk1(m);
     std::shared_lock<mutex> lk2;
@@ -36,4 +36,6 @@
     assert(lk2.mutex() == &m);
     assert(lk2.owns_lock() == true);
     static_assert(noexcept(lk1.swap(lk2)), "member swap must be noexcept");
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp
@@ -27,7 +27,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk1(m);
     std::shared_lock<mutex> lk2;
@@ -37,4 +37,6 @@
     assert(lk2.mutex() == &m);
     assert(lk2.owns_lock() == true);
     static_assert(noexcept(swap(lk1, lk2)), "non-member swap must be noexcept");
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp
@@ -31,7 +31,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<mutex> lk(m);
     assert(lk.mutex() == &m);
@@ -44,4 +44,6 @@
     assert(mutex::lock_count == 1);
     assert(mutex::unlock_count == 0);
     static_assert(noexcept(lk.release()), "release must be noexcept");
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp
@@ -20,7 +20,7 @@
 
 std::shared_timed_mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0;
     assert(lk0.mutex() == nullptr);
@@ -29,4 +29,6 @@
     lk1.unlock();
     assert(lk1.mutex() == &m);
     static_assert(noexcept(lk0.mutex()), "mutex() must be noexcept");
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp
@@ -20,7 +20,7 @@
 
 std::shared_timed_mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0;
     assert(static_cast<bool>(lk0) == false);
@@ -29,4 +29,6 @@
     lk1.unlock();
     assert(static_cast<bool>(lk1) == false);
     static_assert(noexcept(static_cast<bool>(lk0)), "explicit operator bool() must be noexcept");
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp
@@ -20,7 +20,7 @@
 
 std::shared_timed_mutex m;
 
-int main()
+int main(int, char**)
 {
     std::shared_lock<std::shared_timed_mutex> lk0;
     assert(lk0.owns_lock() == false);
@@ -29,4 +29,6 @@
     lk1.unlock();
     assert(lk1.owns_lock() == false);
     static_assert(noexcept(lk0.owns_lock()), "owns_lock must be noexcept");
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp
@@ -23,8 +23,10 @@
 #include <shared_mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::shared_lock<std::mutex>::mutex_type,
                    std::mutex>::value), "");
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
@@ -15,7 +15,7 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -29,4 +29,6 @@
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp
@@ -15,7 +15,7 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -27,4 +27,6 @@
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
@@ -17,9 +17,11 @@
 #include <mutex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> ul;
     assert(!ul.owns_lock());
     assert(ul.mutex() == nullptr);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -44,4 +44,6 @@
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -40,4 +40,6 @@
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
@@ -46,7 +46,7 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
@@ -58,4 +58,6 @@
     std::unique_lock ul(m);
     static_assert((std::is_same<decltype(ul), std::unique_lock<decltype(m)>>::value), "" );
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -36,4 +36,6 @@
     assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "nasty_containers.hpp"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::mutex M;
@@ -34,4 +34,6 @@
     assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == false);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp
@@ -50,7 +50,7 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -66,4 +66,6 @@
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp
@@ -50,7 +50,7 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -66,4 +66,6 @@
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp
@@ -53,11 +53,13 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
@@ -66,11 +66,13 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
@@ -33,7 +33,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
@@ -66,4 +66,6 @@
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
@@ -38,7 +38,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
@@ -71,4 +71,6 @@
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
@@ -37,7 +37,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::steady_clock Clock;
     std::unique_lock<mutex> lk(m, std::defer_lock);
@@ -71,4 +71,6 @@
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp
@@ -29,7 +29,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk(m);
     lk.unlock();
@@ -58,4 +58,6 @@
         assert(e.code().value() == EPERM);
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp
@@ -25,7 +25,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk1(m);
     std::unique_lock<mutex> lk2;
@@ -34,4 +34,6 @@
     assert(lk1.owns_lock() == false);
     assert(lk2.mutex() == &m);
     assert(lk2.owns_lock() == true);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp
@@ -26,7 +26,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk1(m);
     std::unique_lock<mutex> lk2;
@@ -35,4 +35,6 @@
     assert(lk1.owns_lock() == false);
     assert(lk2.mutex() == &m);
     assert(lk2.owns_lock() == true);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp
@@ -30,7 +30,7 @@
 
 mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<mutex> lk(m);
     assert(lk.mutex() == &m);
@@ -42,4 +42,6 @@
     assert(lk.owns_lock() == false);
     assert(mutex::lock_count == 1);
     assert(mutex::unlock_count == 0);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp
@@ -19,7 +19,7 @@
 
 std::mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> lk0;
     assert(lk0.mutex() == nullptr);
@@ -27,4 +27,6 @@
     assert(lk1.mutex() == &m);
     lk1.unlock();
     assert(lk1.mutex() == &m);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp
@@ -19,7 +19,7 @@
 
 std::mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> lk0;
     assert(static_cast<bool>(lk0) == false);
@@ -27,4 +27,6 @@
     assert(static_cast<bool>(lk1) == true);
     lk1.unlock();
     assert(static_cast<bool>(lk1) == false);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp
@@ -19,7 +19,7 @@
 
 std::mutex m;
 
-int main()
+int main(int, char**)
 {
     std::unique_lock<std::mutex> lk0;
     assert(lk0.owns_lock() == false);
@@ -27,4 +27,6 @@
     assert(lk1.owns_lock() == true);
     lk1.unlock();
     assert(lk1.owns_lock() == false);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp
@@ -21,8 +21,10 @@
 #include <mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::unique_lock<std::mutex>::mutex_type,
                    std::mutex>::value), "");
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.lock/types.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.lock/types.pass.cpp
+++ test/std/thread/thread.mutex/thread.lock/types.pass.cpp
@@ -21,7 +21,7 @@
 #include <mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::defer_lock_t T1;
     typedef std::try_to_lock_t T2;
@@ -30,4 +30,6 @@
     T1 t1 = std::defer_lock; ((void)t1);
     T2 t2 = std::try_to_lock; ((void)t2);
     T3 t3 = std::adopt_lock; ((void)t3);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m0;
     std::mutex m1;
     m1 = m0;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::mutex m0;
     std::mutex m1(m0);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
@@ -17,8 +17,10 @@
 #include <mutex>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_nothrow_default_constructible<std::mutex>::value, "");
     std::mutex m;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp
@@ -41,11 +41,13 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp
@@ -41,11 +41,13 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_mutex m0;
     std::recursive_mutex m1;
     m1 = m0;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_mutex m0;
     std::recursive_mutex m1(m0);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp
@@ -16,7 +16,9 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_mutex m;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp
@@ -41,11 +41,13 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp
@@ -43,11 +43,13 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.fail.cpp
@@ -17,9 +17,11 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_mutex m0;
     std::shared_mutex m1;
     m1 = m0; // expected-error {{overload resolution selected deleted operator '='}}
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.fail.cpp
@@ -17,8 +17,10 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_mutex m0;
     std::shared_mutex m1(m0); // expected-error {{call to deleted constructor of 'std::shared_mutex'}}
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
@@ -17,7 +17,9 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_mutex m;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
@@ -53,11 +53,13 @@
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(WaitTime);
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
@@ -65,7 +65,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -84,4 +84,6 @@
     for (auto& t : v)
         t.join();
     q.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
@@ -42,11 +42,13 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
@@ -46,7 +46,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -56,4 +56,6 @@
     m.unlock();
     for (auto& t : v)
         t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp
@@ -15,9 +15,11 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_timed_mutex m0;
     std::shared_timed_mutex m1;
     m1 = m0;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp
@@ -15,8 +15,10 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_timed_mutex m0;
     std::shared_timed_mutex m1(m0);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
@@ -17,7 +17,9 @@
 
 #include <shared_mutex>
 
-int main()
+int main(int, char**)
 {
     std::shared_timed_mutex m;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
@@ -55,11 +55,13 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
@@ -67,7 +67,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -86,4 +86,6 @@
     for (auto& t : v)
         t.join();
     q.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
@@ -42,11 +42,13 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
@@ -64,7 +64,7 @@
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -80,4 +80,6 @@
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
@@ -54,7 +54,7 @@
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
@@ -64,4 +64,6 @@
     m.unlock();
     for (auto& t : v)
         t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
@@ -64,7 +64,7 @@
     assert(d < Tolerance);  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -86,4 +86,6 @@
         for (auto& t : v)
             t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
@@ -64,7 +64,7 @@
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -86,4 +86,6 @@
         for (auto& t : v)
             t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
@@ -64,7 +64,7 @@
     assert(d < Tolerance);  // within tolerance
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -80,4 +80,6 @@
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
@@ -47,7 +47,7 @@
   m.unlock_shared();
 }
 
-int main()
+int main(int, char**)
 {
   typedef std::chrono::steady_clock Clock;
 
@@ -66,4 +66,6 @@
   t1.join();
   t2.join();
   t3.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::timed_mutex m0;
     std::timed_mutex m1;
     m1 = m0;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::timed_mutex m0;
     std::timed_mutex m1(m0);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp
@@ -16,7 +16,9 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::timed_mutex m;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp
@@ -39,11 +39,13 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp
@@ -41,11 +41,13 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp
@@ -47,7 +47,7 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -63,4 +63,6 @@
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp
@@ -47,7 +47,7 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -63,4 +63,6 @@
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_timed_mutex m0;
     std::recursive_timed_mutex m1;
     m1 = m0;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_timed_mutex m0;
     std::recursive_timed_mutex m1(m0);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp
@@ -16,7 +16,9 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::recursive_timed_mutex m;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp
@@ -43,11 +43,13 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp
@@ -43,11 +43,13 @@
     assert(d < ms(200));  // within 200ms
 }
 
-int main()
+int main(int, char**)
 {
     m.lock();
     std::thread t(f);
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     t.join();
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp
@@ -49,7 +49,7 @@
     assert(d < ns(50000000));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -65,4 +65,6 @@
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp
+++ test/std/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp
@@ -49,7 +49,7 @@
     assert(d < ms(50));  // within 50ms
 }
 
-int main()
+int main(int, char**)
 {
     {
         m.lock();
@@ -65,4 +65,6 @@
         m.unlock();
         t.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp
+++ test/std/thread/thread.mutex/thread.once/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
+++ test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp
@@ -186,7 +186,7 @@
 
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     // check basic functionality
     {
@@ -253,4 +253,6 @@
         assert(rq.rv_called == 1);
     }
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp
+++ test/std/thread/thread.mutex/thread.once/thread.once.callonce/race.pass.cpp
@@ -37,11 +37,13 @@
     assert(global == 1);
 }
 
-int main()
+int main(int, char**)
 {
     std::thread t0(f0);
     std::thread t1(f0);
     t0.join();
     t1.join();
     assert(global == 1);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp
+++ test/std/thread/thread.mutex/thread.once/thread.once.onceflag/assign.fail.cpp
@@ -14,9 +14,11 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::once_flag f;
     std::once_flag f2;
     f2 = f;
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp
+++ test/std/thread/thread.mutex/thread.once/thread.once.onceflag/copy.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <mutex>
 
-int main()
+int main(int, char**)
 {
     std::once_flag f;
     std::once_flag f2(f);
+
+  return 0;
 }
Index: test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
===================================================================
--- test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
+++ test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
@@ -15,7 +15,7 @@
 #include <mutex>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::once_flag f;
@@ -27,4 +27,6 @@
     (void)f;
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.req/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/thread.req.exception/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/thread.req.lockable/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.basic/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/thread.req.lockable/thread.req.lockable.timed/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/thread.req.native/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/thread.req.paramname/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp
===================================================================
--- test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp
+++ test/std/thread/thread.req/thread.req.timing/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp
@@ -41,7 +41,7 @@
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -54,4 +54,6 @@
         assert(t1.get_id() == id0);
         t1.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/copy.fail.cpp
@@ -40,11 +40,13 @@
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         std::thread t0(G());
         std::thread t1;
         t1 = t0;
     }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp
@@ -41,7 +41,7 @@
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         assert(G::n_alive == 0);
@@ -59,4 +59,6 @@
         assert(G::n_alive == 0);
         assert(G::op_run);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.assign/move2.pass.cpp
@@ -51,7 +51,7 @@
     std::_Exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     {
@@ -61,4 +61,6 @@
         t0 = std::move(t1);
         assert(false);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
@@ -144,7 +144,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_throwing_new_during_thread_creation();
     {
@@ -200,4 +200,6 @@
         t.join();
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/constr.fail.cpp
@@ -18,8 +18,10 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     volatile std::thread t1;
     std::thread t2 ( t1, 1, 2.0 );
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/copy.fail.cpp
@@ -48,7 +48,7 @@
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         assert(G::n_alive == 0);
@@ -62,4 +62,6 @@
         assert(G::n_alive == 0);
         assert(G::op_run);
     }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp
@@ -17,8 +17,10 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread t;
     assert(t.get_id() == std::thread::id());
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp
@@ -50,7 +50,7 @@
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -66,4 +66,6 @@
         assert(G::op_run);
     }
     assert(G::n_alive == 0);
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
@@ -47,7 +47,7 @@
     std::_Exit(0);
 }
 
-int main()
+int main(int, char**)
 {
     std::set_terminate(f1);
     {
@@ -60,4 +60,6 @@
         }
     }
     assert(false);
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp
@@ -17,7 +17,7 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0;
     std::thread::id id1;
@@ -25,4 +25,6 @@
     assert(id1 == id0);
     id1 = std::this_thread::get_id();
     assert(id1 != id0);
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp
@@ -17,9 +17,11 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0;
     std::thread::id id1 = id0;
     assert(id1 == id0);
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp
@@ -17,8 +17,10 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id;
     assert(id == std::thread::id());
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.id/enabled_hashes.pass.cpp
@@ -18,9 +18,11 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::thread::id>();
   }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp
@@ -18,7 +18,7 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0;
     std::thread::id id1;
@@ -28,4 +28,6 @@
     id1 = std::this_thread::get_id();
     assert(!(id1 == id0));
     assert( (id1 != id0));
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp
@@ -20,7 +20,7 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0;
     std::thread::id id1;
@@ -39,4 +39,6 @@
       assert( (id0 >  id2));
       assert( (id0 >= id2));
     }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp
@@ -20,9 +20,11 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id0 = std::this_thread::get_id();
     std::ostringstream os;
     os << id0;
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::thread::id id1;
     std::thread::id id2 = std::this_thread::get_id();
@@ -34,4 +34,6 @@
     ASSERT_NOEXCEPT(H()(id2));
     H h;
     assert(h(id1) != h(id2));
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp
@@ -61,7 +61,7 @@
 
 void foo() {}
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -86,4 +86,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp
@@ -41,7 +41,7 @@
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -54,4 +54,6 @@
         assert(t1.get_id() == std::thread::id());
         t0.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp
@@ -46,7 +46,7 @@
 
 void foo() {}
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -73,4 +73,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp
@@ -41,7 +41,7 @@
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -50,4 +50,6 @@
         t0.join();
         assert(!t0.joinable());
     }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp
@@ -41,7 +41,7 @@
 int G::n_alive = 0;
 bool G::op_run = false;
 
-int main()
+int main(int, char**)
 {
     {
         G g;
@@ -54,4 +54,6 @@
         assert(t1.get_id() == id0);
         t1.join();
     }
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp
@@ -17,7 +17,9 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::thread::hardware_concurrency() > 0);
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.this/get_id.pass.cpp
@@ -15,8 +15,10 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::thread::id id = std::this_thread::get_id();
     assert(id != std::thread::id());
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.this/sleep_for_tested_elsewhere.pass.cpp
@@ -16,6 +16,8 @@
 // is therefore non-standard. For this reason the test lives under the 'libcxx'
 // subdirectory.
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
@@ -18,7 +18,7 @@
 #include <cstdlib>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef Clock::time_point time_point;
@@ -30,4 +30,6 @@
     std::chrono::nanoseconds err = 5 * ms / 100;
     // The time slept is within 5% of 500ms
     assert(std::abs(ns.count()) < err.count());
+
+  return 0;
 }
Index: test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp
===================================================================
--- test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp
+++ test/std/thread/thread.threads/thread.thread.this/yield.pass.cpp
@@ -15,7 +15,9 @@
 #include <thread>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::this_thread::yield();
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/allocs.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -113,4 +113,6 @@
              std::scoped_allocator_adaptor<A1<int>>,
              std::scoped_allocator_adaptor<A2<int>>>::value, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_copy.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<double>> B;
@@ -64,4 +64,6 @@
         assert(a2 == a1);
     }
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/converting_move.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<double>> B;
@@ -69,4 +69,6 @@
         assert(A3<int>::move_called == true);
         assert(a2 == a1);
     }
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/copy.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -64,4 +64,6 @@
         assert(A3<int>::move_called == false);
         assert(a2 == a1);
     }
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.cnstr/default.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -53,4 +53,6 @@
         assert(A3<int>::move_called == false);
     }
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
@@ -21,8 +21,10 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     std::scoped_allocator_adaptor<A1<int>> a;
     a.allocate(10);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -44,4 +44,6 @@
         assert(A1<int>::allocate_called == true);
     }
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
@@ -21,8 +21,10 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     std::scoped_allocator_adaptor<A1<int>> a;
     a.allocate(10, (const void*)0); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -65,4 +65,6 @@
         assert(a.allocate(10, (const void*)20) == (int*)20);
         assert(A2<int>::allocate_called == true);
     }
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp
@@ -110,7 +110,7 @@
 
 bool F::constructed = false;
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -184,4 +184,6 @@
         assert(A3<F>::constructed);
         s->~S();
     }
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
@@ -135,7 +135,9 @@
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
@@ -151,7 +151,9 @@
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
@@ -152,7 +152,9 @@
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
@@ -151,7 +151,9 @@
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
@@ -143,7 +143,9 @@
         std::free(ptr);
     }
 }
-int main() {
+int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
@@ -125,8 +125,10 @@
     POuter.reset();
 }
 
-int main() {
+int main(int, char**) {
     test_bullet_one();
     test_bullet_two();
     test_bullet_three();
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/deallocate.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -42,4 +42,6 @@
         assert((A1<int>::deallocate_called == std::pair<int*, std::size_t>((int*)10, 20)));
     }
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/destroy.pass.cpp
@@ -31,7 +31,7 @@
 
 bool B::constructed = false;
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<B>> A;
@@ -65,4 +65,6 @@
         assert(A3<S>::destroy_called);
     }
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/inner_allocator.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -40,4 +40,6 @@
             std::scoped_allocator_adaptor<A2<int>, A3<int>>(A2<int>(6), A3<int>(8))));
     }
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/max_size.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -38,4 +38,6 @@
         assert(a.max_size() == 200);
     }
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/outer_allocator.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -39,4 +39,6 @@
         A a(A1<int>(5), A2<int>(6), A3<int>(8));
         assert(a.outer_allocator() == A1<int>(5));
     }
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/select_on_container_copy_construction.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -50,4 +50,6 @@
         assert(a2.inner_allocator().inner_allocator().outer_allocator().id() == -1);
     }
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp
@@ -109,7 +109,7 @@
 
 struct Foo { int x; };
 
-int main()
+int main(int, char**)
 {
     test_pointer<std::scoped_allocator_adaptor<std::allocator<char>>> ();
     test_pointer<std::scoped_allocator_adaptor<std::allocator<int>>> ();
@@ -118,7 +118,9 @@
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<char>>> ();
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<int>>> ();
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<Foo>>> ();
+
+  return 0;
 }
 #else
-int main() {}
+int main(int, char**) { return 0; }
 #endif
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.types/inner_allocator_type.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::inner_allocator_type,
@@ -33,4 +33,6 @@
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::inner_allocator_type,
         std::scoped_allocator_adaptor<A2<int>, A3<int>>>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
@@ -21,7 +21,7 @@
 #include "allocators.h"
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     // sanity checks
     static_assert( (std::is_same<
@@ -68,4 +68,6 @@
               std::allocator_traits<A2<int>>::is_always_equal::value &&
               std::allocator_traits<A3<int>>::is_always_equal::value)
         ), "");
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_copy_assignment.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::propagate_on_container_copy_assignment,
@@ -34,4 +34,6 @@
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::propagate_on_container_copy_assignment,
         std::true_type>::value), "");
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_move_assignment.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::propagate_on_container_move_assignment,
@@ -34,4 +34,6 @@
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::propagate_on_container_move_assignment,
         std::true_type>::value), "");
 
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.types/propagate_on_container_swap.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>>::propagate_on_container_swap,
@@ -33,4 +33,6 @@
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A1<int>, A2<int>, A3<int>>::propagate_on_container_swap,
         std::true_type>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
+++ test/std/utilities/allocator.adaptor/scoped.adaptor.operators/copy_assign.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -68,4 +68,6 @@
         assert(A3<int>::move_called == false);
         assert(aN == a1);
     }
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
+++ test/std/utilities/allocator.adaptor/scoped.adaptor.operators/eq.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -58,4 +58,6 @@
         assert(a2 != a1);
         assert(!(a2 == a1));
     }
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
+++ test/std/utilities/allocator.adaptor/scoped.adaptor.operators/move_assign.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::scoped_allocator_adaptor<A1<int>> A;
@@ -68,4 +68,6 @@
         assert(A3<int>::move_called == true);
         assert(aN == a1);
     }
+
+  return 0;
 }
Index: test/std/utilities/allocator.adaptor/types.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/types.pass.cpp
+++ test/std/utilities/allocator.adaptor/types.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "allocators.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<
         A1<int>,
@@ -96,4 +96,6 @@
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A2<int>, A1<int>>::const_void_pointer,
         const void*>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.assign/copy.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.assign/copy.pass.cpp
+++ test/std/utilities/any/any.class/any.assign/copy.pass.cpp
@@ -191,7 +191,7 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
     test_copy_assign<small1, small2>();
     test_copy_assign<large1, large2>();
     test_copy_assign<small, large>();
@@ -201,4 +201,6 @@
     test_copy_assign_self();
     test_copy_assign_throws<small_throws_on_copy>();
     test_copy_assign_throws<large_throws_on_copy>();
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.assign/move.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.assign/move.pass.cpp
+++ test/std/utilities/any/any.class/any.assign/move.pass.cpp
@@ -104,7 +104,7 @@
       );
 }
 
-int main() {
+int main(int, char**) {
     test_move_assign_noexcept();
     test_move_assign<small1, small2>();
     test_move_assign<large1, large2>();
@@ -112,4 +112,6 @@
     test_move_assign<large, small>();
     test_move_assign_empty<small>();
     test_move_assign_empty<large>();
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.assign/value.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.assign/value.pass.cpp
+++ test/std/utilities/any/any.class/any.assign/value.pass.cpp
@@ -202,7 +202,7 @@
     }
 }
 
-int main() {
+int main(int, char**) {
     test_assign_value<small1, small2>();
     test_assign_value<large1, large2>();
     test_assign_value<small, large>();
@@ -213,4 +213,6 @@
     test_assign_throws<large_throws_on_copy>();
     test_assign_throws<throws_on_move, /* Move = */ true>();
     test_sfinae_constraints();
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.cons/copy.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.cons/copy.pass.cpp
+++ test/std/utilities/any/any.class/any.cons/copy.pass.cpp
@@ -98,10 +98,12 @@
     assert(Type::count == 0);
 }
 
-int main() {
+int main(int, char**) {
     test_copy<small>();
     test_copy<large>();
     test_copy_empty();
     test_copy_throws<small_throws_on_copy>();
     test_copy_throws<large_throws_on_copy>();
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.cons/default.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.cons/default.pass.cpp
+++ test/std/utilities/any/any.class/any.cons/default.pass.cpp
@@ -20,7 +20,7 @@
 #include "any_helpers.h"
 #include "count_new.hpp"
 
-int main()
+int main(int, char**)
 {
     using std::any;
     {
@@ -43,4 +43,6 @@
         any const a;
         assertEmpty(a);
     }
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
+++ test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
@@ -187,7 +187,7 @@
     static_assert(std::is_constructible<std::any, IT, std::initializer_list<int>&, int>::value, "");
 }
 
-int main() {
+int main(int, char**) {
     test_in_place_type<small>();
     test_in_place_type<large>();
     test_in_place_type<small_throws_on_copy>();
@@ -198,4 +198,6 @@
     test_in_place_type_decayed();
     test_ctor_sfinae();
     test_constructor_explicit();
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.cons/move.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.cons/move.pass.cpp
+++ test/std/utilities/any/any.class/any.cons/move.pass.cpp
@@ -95,7 +95,7 @@
     assert(Type::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     // noexcept test
     {
@@ -108,4 +108,6 @@
     test_move<large>();
     test_move_empty();
     test_move_does_not_throw();
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.cons/value.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.cons/value.pass.cpp
+++ test/std/utilities/any/any.class/any.cons/value.pass.cpp
@@ -151,11 +151,13 @@
     }
 }
 
-int main() {
+int main(int, char**) {
     test_copy_move_value<small>();
     test_copy_move_value<large>();
     test_copy_value_throws<small_throws_on_copy>();
     test_copy_value_throws<large_throws_on_copy>();
     test_move_value_throws();
     test_sfinae_constraints();
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
+++ test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp
@@ -275,7 +275,7 @@
     }
 }
 
-int main() {
+int main(int, char**) {
     test_emplace_type<small>();
     test_emplace_type<large>();
     test_emplace_type<small_throws_on_copy>();
@@ -288,4 +288,6 @@
     test_emplace_throws<SmallThrows>();
     test_emplace_throws<LargeThrows>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
+++ test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "any_helpers.h"
 
-int main()
+int main(int, char**)
 {
     using std::any;
     using std::any_cast;
@@ -67,4 +67,6 @@
         assertEmpty<large>(a);
         assert(large::count == 0);
     }
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
+++ test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp
@@ -127,7 +127,7 @@
     assert(large::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test_noexcept();
     test_swap_empty<small>();
@@ -137,4 +137,6 @@
     test_swap<small, large>();
     test_swap<large, small>();
     test_self_swap();
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.observers/has_value.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.observers/has_value.pass.cpp
+++ test/std/utilities/any/any.class/any.observers/has_value.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "any_helpers.h"
 
-int main()
+int main(int, char**)
 {
     using std::any;
     // noexcept test
@@ -60,4 +60,6 @@
         a = l;
         assert(a.has_value());
     }
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/any.observers/type.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.observers/type.pass.cpp
+++ test/std/utilities/any/any.class/any.observers/type.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "any_helpers.h"
 
-int main()
+int main(int, char**)
 {
     using std::any;
     {
@@ -37,4 +37,6 @@
         any const a(l);
         assert(a.type() == typeid(large));
     }
+
+  return 0;
 }
Index: test/std/utilities/any/any.class/not_literal_type.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/not_literal_type.pass.cpp
+++ test/std/utilities/any/any.class/not_literal_type.pass.cpp
@@ -15,6 +15,8 @@
 #include <any>
 #include <type_traits>
 
-int main () {
+int main(int, char**) {
     static_assert(!std::is_literal_type<std::any>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
===================================================================
--- test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
+++ test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp
@@ -166,7 +166,7 @@
     assert(fn_ptr == test_fn);
 }
 
-int main() {
+int main(int, char**) {
     test_cast_is_noexcept();
     test_cast_return_type();
     test_cast_nullptr();
@@ -175,4 +175,6 @@
     test_cast<large>();
     test_cast_non_copyable_type();
     test_cast_function_pointer();
+
+  return 0;
 }
Index: test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
===================================================================
--- test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
+++ test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
@@ -309,7 +309,7 @@
     assert(Type::count == 0);
 }
 
-int main() {
+int main(int, char**) {
     test_cast_is_not_noexcept();
     test_cast_return_type();
     test_cast_empty();
@@ -317,4 +317,6 @@
     test_cast_to_reference<large>();
     test_cast_to_value<small>();
     test_cast_to_value<large>();
+
+  return 0;
 }
Index: test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
===================================================================
--- test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
+++ test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
@@ -61,9 +61,11 @@
     any_cast<int&>(42);
 }
 
-int main()
+int main(int, char**)
 {
     test_const_lvalue_cast_request_non_const_lvalue();
     test_lvalue_any_cast_request_rvalue();
     test_rvalue_any_cast_request_lvalue();
+
+  return 0;
 }
Index: test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
===================================================================
--- test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
+++ test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
@@ -24,7 +24,7 @@
 // is triggered by these tests.
 // expected-error@const_correctness.fail.cpp:* 0+ {{call to unavailable function 'any_cast': introduced in macOS 10.14}}
 
-int main()
+int main(int, char**)
 {
     using std::any;
     using std::any_cast;
@@ -46,4 +46,6 @@
     // expected-error@any:* {{cannot cast from lvalue of type 'const TestType2' to rvalue reference type 'TestType2 &&'; types are not compatible}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType2 &&>(static_cast<any const&&>(a)); // expected-note {{requested here}}
+
+  return 0;
 }
Index: test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
===================================================================
--- test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
+++ test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
@@ -43,7 +43,7 @@
 // is triggered by these tests.
 // expected-error@not_copy_constructible.fail.cpp:* 0+ {{call to unavailable function 'any_cast': introduced in macOS 10.14}}
 
-int main() {
+int main(int, char**) {
     any a;
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{static_cast from 'no_copy' to 'no_copy' uses deleted function}}
@@ -58,4 +58,6 @@
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{static_cast from 'typename remove_reference<no_move &>::type' (aka 'no_move') to 'no_move' uses deleted function}}
     any_cast<no_move>(static_cast<any &&>(a));
+
+  return 0;
 }
Index: test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
===================================================================
--- test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
+++ test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
@@ -21,7 +21,7 @@
 using std::any;
 using std::any_cast;
 
-int main()
+int main(int, char**)
 {
     any a(1);
 
@@ -50,4 +50,6 @@
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int const &&>(&a2); // expected-note {{requested here}}
+
+  return 0;
 }
Index: test/std/utilities/any/any.nonmembers/make_any.pass.cpp
===================================================================
--- test/std/utilities/any/any.nonmembers/make_any.pass.cpp
+++ test/std/utilities/any/any.nonmembers/make_any.pass.cpp
@@ -131,7 +131,7 @@
 
 #endif
 
-int main() {
+int main(int, char**) {
     test_make_any_type<small>();
     test_make_any_type<large>();
     test_make_any_type<small_throws_on_copy>();
@@ -144,4 +144,6 @@
     test_make_any_throws<LargeThrows>();
 
 #endif
+
+  return 0;
 }
Index: test/std/utilities/any/any.nonmembers/swap.pass.cpp
===================================================================
--- test/std/utilities/any/any.nonmembers/swap.pass.cpp
+++ test/std/utilities/any/any.nonmembers/swap.pass.cpp
@@ -28,7 +28,7 @@
 using std::any;
 using std::any_cast;
 
-int main()
+int main(int, char**)
 {
 
     { // test noexcept
@@ -44,4 +44,6 @@
         assert(any_cast<int>(a1) == 2);
         assert(any_cast<int>(a2) == 1);
     }
+
+  return 0;
 }
Index: test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp
===================================================================
--- test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp
+++ test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp
@@ -18,7 +18,7 @@
 
 #include <charconv>
 
-int main()
+int main(int, char**)
 {
     using std::from_chars;
     char buf[] = "01001";
@@ -26,4 +26,6 @@
 
     from_chars(buf, buf + sizeof(buf), lv);      // expected-error {{call to deleted function}}
     from_chars(buf, buf + sizeof(buf), lv, 16);  // expected-error {{call to deleted function}}
+
+  return 0;
 }
Index: test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
===================================================================
--- test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
+++ test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp
@@ -183,8 +183,10 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     run<test_basics>(integrals);
     run<test_signed>(all_signed);
+
+  return 0;
 }
Index: test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp
===================================================================
--- test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp
+++ test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp
@@ -18,7 +18,7 @@
 
 #include <charconv>
 
-int main()
+int main(int, char**)
 {
     using std::to_chars;
     char buf[10];
@@ -26,4 +26,6 @@
 
     to_chars(buf, buf + sizeof(buf), false);   // expected-error {{call to deleted function}}
     to_chars(buf, buf + sizeof(buf), lv, 16);  // expected-error {{call to deleted function}}
+
+  return 0;
 }
Index: test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
===================================================================
--- test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
+++ test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
@@ -81,8 +81,10 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     run<test_basics>(integrals);
     run<test_signed>(all_signed);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp
===================================================================
--- test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp
+++ test/std/utilities/function.objects/arithmetic.operations/divides.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::divides<int> F;
     const F f = F();
@@ -37,4 +37,6 @@
     constexpr double bar = std::divides<> () (3.0, 2);
     static_assert ( bar == 1.5, "" ); // exact in binary
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp
===================================================================
--- test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp
+++ test/std/utilities/function.objects/arithmetic.operations/minus.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::minus<int> F;
     const F f = F();
@@ -37,4 +37,6 @@
     constexpr double bar = std::minus<> () (3.0, 2);
     static_assert ( bar == 1.0, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp
===================================================================
--- test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp
+++ test/std/utilities/function.objects/arithmetic.operations/modulus.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::modulus<int> F;
     const F f = F();
@@ -37,4 +37,6 @@
     constexpr int bar = std::modulus<> () (3L, 2);
     static_assert ( bar == 1, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp
===================================================================
--- test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp
+++ test/std/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::multiplies<int> F;
     const F f = F();
@@ -37,4 +37,6 @@
     constexpr double bar = std::multiplies<> () (3.0, 2);
     static_assert ( bar == 6.0, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp
===================================================================
--- test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp
+++ test/std/utilities/function.objects/arithmetic.operations/negate.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::negate<int> F;
     const F f = F();
@@ -36,4 +36,6 @@
     constexpr double bar = std::negate<> () (3.0);
     static_assert ( bar == -3.0, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
===================================================================
--- test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
+++ test/std/utilities/function.objects/arithmetic.operations/plus.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::plus<int> F;
     const F f = F();
@@ -37,4 +37,6 @@
     constexpr double bar = std::plus<> () (3.0, 2);
     static_assert ( bar == 5.0, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
===================================================================
--- test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
+++ test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
@@ -22,7 +22,7 @@
 };
 
 
-int main ()
+int main(int, char**)
 {
     static_assert ( !is_transparent<std::plus<int>>::value, "" );
     static_assert ( !is_transparent<std::plus<std::string>>::value, "" );
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/PR23141_invoke_not_constexpr.pass.cpp
@@ -28,7 +28,9 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     std::bind(Fun{}, std::placeholders::_1, 42)("hello");
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp
@@ -115,7 +115,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     do_test<int>(return_value);
     do_test<int&>(return_lvalue);
@@ -129,4 +129,6 @@
     do_test_r<long>(return_rvalue);
     do_test_r<long>(return_const_rvalue);
 
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
@@ -26,11 +26,13 @@
     return std::pow(a, b);
 }
 
-int main()
+int main(int, char**)
 {
     std::function<float(float, float)> fnc = _pow;
     auto task = std::bind(fnc, 2.f, 4.f);
     auto task2(task);
     assert(task() == 16);
     assert(task2() == 16);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
@@ -38,7 +38,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     // Check that BadUnaryFunction::operator()(S const &) is not
     // instantiated when checking if BadUnaryFunction is a nested bind
@@ -47,4 +47,6 @@
     b(0);
     auto b2 = std::bind<long>(DummyUnaryFunction(), BadUnaryFunction());
     b2(0);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
@@ -40,7 +40,7 @@
     int operator()() const {return 5;}
 };
 
-int main()
+int main(int, char**)
 {
     test(std::bind(f), 1);
     test(std::bind(&f), 1);
@@ -51,4 +51,6 @@
     test(std::bind<int>(&f), 1);
     test(std::bind<int>(A_int_0()), 4);
     test_const(std::bind<int>(A_int_0()), 5);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
@@ -280,10 +280,12 @@
     assert(b);
 }
 
-int main()
+int main(int, char**)
 {
     test_void_1();
     test_int_1();
     test_void_2();
     test3();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
@@ -258,10 +258,12 @@
     assert(std::bind(f_nested, std::bind(g_nested, _1))(3) == 31);
 }
 
-int main()
+int main(int, char**)
 {
     test_void_1();
     test_int_1();
     test_void_2();
     test_nested();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
@@ -54,7 +54,7 @@
     int operator()() const {count += 2; return 5;}
 };
 
-int main()
+int main(int, char**)
 {
     test(std::bind(f));
     test(std::bind(&f));
@@ -70,4 +70,6 @@
     test(std::bind<void>(&g));
     test(std::bind<void>(A_int_0()));
     test_const(std::bind<void>(A_int_0()));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
@@ -41,11 +41,13 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     using std::placeholders::_1;
 
     auto g = std::bind(power(), 2, _1);
     assert(g(5) == 32);
     assert(std::bind(plus_one(), g)(5) == 33);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp
@@ -27,11 +27,13 @@
 
 struct C {};
 
-int main()
+int main(int, char**)
 {
     test<true>(std::bind(C()));
     test<true>(std::bind(C(), std::placeholders::_2));
     test<true>(std::bind<int>(C()));
     test<false>(1);
     test<false>(std::placeholders::_2);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression_03.pass.cpp
@@ -24,7 +24,7 @@
 
 struct C {};
 
-int main() {
+int main(int, char**) {
     test<int>();
     test<void>();
     test<C>();
@@ -35,4 +35,6 @@
     test<int(*)()>();
     test<int (C::*)()>();
     test<decltype(std::placeholders::_2)>();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp
@@ -25,7 +25,7 @@
 
 struct C {};
 
-int main()
+int main(int, char**)
 {
     test<1>(std::placeholders::_1);
     test<2>(std::placeholders::_2);
@@ -41,4 +41,6 @@
     test<0>(5.5);
     test<0>('a');
     test<0>(C());
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp
@@ -80,7 +80,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     use_placeholders_to_prevent_unused_warning();
     test(std::placeholders::_1);
@@ -93,4 +93,6 @@
     test(std::placeholders::_8);
     test(std::placeholders::_9);
     test(std::placeholders::_10);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp
+++ test/std/utilities/function.objects/bind/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp
+++ test/std/utilities/function.objects/bitwise.operations/bit_and.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::bit_and<int> F;
     const F f = F();
@@ -57,4 +57,6 @@
     constexpr int bar = std::bit_and<> () (0x58D3L, 0xEA95);
     static_assert ( bar == 0x4891, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
+++ test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp
@@ -15,7 +15,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::bit_not<int> F;
     const F f = F();
@@ -42,4 +42,6 @@
 
     constexpr int bar = std::bit_not<> () (0xEA95) & 0xFFFF;
     static_assert ( bar == 0x156A, "" );
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp
+++ test/std/utilities/function.objects/bitwise.operations/bit_or.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::bit_or<int> F;
     const F f = F();
@@ -57,4 +57,6 @@
     constexpr int bar = std::bit_or<> () (0x58D3L, 0xEA95);
     static_assert ( bar == 0xFAD7, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp
+++ test/std/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::bit_xor<int> F;
@@ -61,4 +61,6 @@
     static_assert ( bar == 0xB246, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
+++ test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
@@ -22,7 +22,7 @@
 };
 
 
-int main () {
+int main(int, char**) {
     static_assert ( !is_transparent<std::bit_and<int>>::value, "" );
     static_assert ( !is_transparent<std::bit_and<std::string>>::value, "" );
     static_assert (  is_transparent<std::bit_and<void>>::value, "" );
Index: test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp
===================================================================
--- test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp
+++ test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp
@@ -42,6 +42,8 @@
 static_assert(test_constexpr_context<void>(), "");
 
 
-int main() {
+int main(int, char**) {
 
+
+  return 0;
 }
Index: test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
===================================================================
--- test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
+++ test/std/utilities/function.objects/comparisons/equal_to.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::equal_to<int> F;
     const F f = F();
@@ -39,4 +39,6 @@
     constexpr bool bar = std::equal_to<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/comparisons/greater.pass.cpp
===================================================================
--- test/std/utilities/function.objects/comparisons/greater.pass.cpp
+++ test/std/utilities/function.objects/comparisons/greater.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "pointer_comparison_test_helper.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::greater<int> F;
     const F f = F();
@@ -49,4 +49,6 @@
     constexpr bool bar = std::greater<> () (36.0, 36);
     static_assert ( !bar, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
===================================================================
--- test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
+++ test/std/utilities/function.objects/comparisons/greater_equal.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "pointer_comparison_test_helper.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::greater_equal<int> F;
     const F f = F();
@@ -49,4 +49,6 @@
     constexpr bool bar = std::greater_equal<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/comparisons/less.pass.cpp
===================================================================
--- test/std/utilities/function.objects/comparisons/less.pass.cpp
+++ test/std/utilities/function.objects/comparisons/less.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "pointer_comparison_test_helper.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::less<int> F;
     const F f = F();
@@ -48,4 +48,6 @@
     constexpr bool bar = std::less<> () (36.0, 36);
     static_assert ( !bar, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
===================================================================
--- test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
+++ test/std/utilities/function.objects/comparisons/less_equal.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "pointer_comparison_test_helper.hpp"
 
-int main()
+int main(int, char**)
 {
     typedef std::less_equal<int> F;
     const F f = F();
@@ -49,4 +49,6 @@
     constexpr bool bar = std::less_equal<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
===================================================================
--- test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
+++ test/std/utilities/function.objects/comparisons/not_equal_to.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::not_equal_to<int> F;
     const F f = F();
@@ -41,4 +41,6 @@
     constexpr bool bar = std::not_equal_to<> () (36.0, 36);
     static_assert ( !bar, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/comparisons/transparent.pass.cpp
===================================================================
--- test/std/utilities/function.objects/comparisons/transparent.pass.cpp
+++ test/std/utilities/function.objects/comparisons/transparent.pass.cpp
@@ -22,7 +22,7 @@
 };
 
 
-int main ()
+int main(int, char**)
 {
     static_assert ( !is_transparent<std::less<int>>::value, "" );
     static_assert ( !is_transparent<std::less<std::string>>::value, "" );
Index: test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp
+++ test/std/utilities/function.objects/func.def/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
+++ test/std/utilities/function.objects/func.invoke/invoke.pass.cpp
@@ -340,9 +340,11 @@
     }
 }
 
-int main() {
+int main(int, char**) {
     bullet_one_two_tests();
     bullet_three_four_tests();
     bullet_five_tests();
     noexcept_test();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
+++ test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
@@ -31,8 +31,10 @@
 
 int foo(int) { return 42; }
 
-int main() {
+int main(int, char**) {
 #if defined(__cpp_lib_invoke)
   assert(std::invoke(foo, 101) == 42);
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.memfn/member_data.fail.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_data.fail.cpp
+++ test/std/utilities/function.objects/func.memfn/member_data.fail.cpp
@@ -35,7 +35,9 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test(std::mem_fn(&A::data_));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.memfn/member_data.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_data.pass.cpp
+++ test/std/utilities/function.objects/func.memfn/member_data.pass.cpp
@@ -36,7 +36,9 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test(std::mem_fn(&A::data_));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
+++ test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
@@ -65,7 +65,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
@@ -73,4 +73,6 @@
 #if TEST_STD_VER >= 11
     static_assert((noexcept(std::mem_fn(&A::test0))), ""); // LWG#2489
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
+++ test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
@@ -69,9 +69,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
+++ test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
@@ -69,9 +69,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
+++ test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
@@ -69,9 +69,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
+++ test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
@@ -602,7 +602,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     constructor_tests();
     return_type_tests();
@@ -612,4 +612,6 @@
     call_operator_forwarding_test();
     call_operator_noexcept_test();
     test_lwg2767();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
+++ test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
@@ -12,4 +12,6 @@
 // since they require calling the implementation specific "__invoke" and
 // "__invoke_constexpr" functions.
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/utilities/function.objects/func.require/binary_function.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.require/binary_function.pass.cpp
+++ test/std/utilities/function.objects/func.require/binary_function.pass.cpp
@@ -15,10 +15,12 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::binary_function<int, short, bool> bf;
     static_assert((std::is_same<bf::first_argument_type, int>::value), "");
     static_assert((std::is_same<bf::second_argument_type, short>::value), "");
     static_assert((std::is_same<bf::result_type, bool>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.require/unary_function.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.require/unary_function.pass.cpp
+++ test/std/utilities/function.objects/func.require/unary_function.pass.cpp
@@ -15,9 +15,11 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::unary_function<int, bool> uf;
     static_assert((std::is_same<uf::argument_type, int>::value), "");
     static_assert((std::is_same<uf::result_type, bool>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
@@ -122,7 +122,9 @@
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
@@ -118,7 +118,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
@@ -136,7 +136,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
@@ -127,7 +127,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
@@ -122,7 +122,9 @@
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
@@ -117,7 +117,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
@@ -130,7 +130,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
@@ -124,7 +124,9 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
     test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
@@ -82,7 +82,7 @@
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -92,4 +92,6 @@
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
+++ test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
@@ -89,7 +89,7 @@
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
 }
 
-int main() {
+int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
@@ -99,4 +99,6 @@
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp
+++ test/std/utilities/function.objects/func.search/nothing_to_do.pass.cpp
@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp
@@ -19,7 +19,9 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_function_call>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp
@@ -13,7 +13,9 @@
 #include <functional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     std::bad_function_call ex;
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.fail.cpp
@@ -18,7 +18,9 @@
 
 struct S : public std::function<void()> { using function::function; };
 
-int main() {
+int main(int, char**) {
    S f1( [](){} );
    S f2(std::allocator_arg, std::allocator<int>{}, f1);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
@@ -20,10 +20,12 @@
 using Fn = std::function<void()>;
 struct S : public std::function<void()> { using function::function; };
 
-int main() {
+int main(int, char**) {
     S s( [](){} );
     S f1( s );
 #if TEST_STD_VER <= 14
     S f2(std::allocator_arg, std::allocator<int>{}, s);
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
@@ -57,7 +57,7 @@
 int g(int) {return 0;}
 int h(int) {return 1;}
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -132,4 +132,6 @@
     }
     assert(A::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp
@@ -17,7 +17,7 @@
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f;
@@ -25,4 +25,6 @@
     f = g;
     assert(f);
     }
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp
@@ -60,7 +60,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -111,4 +111,6 @@
         static_assert(!std::is_constructible<Fn, RValueCallable>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
@@ -63,7 +63,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -115,4 +115,6 @@
         static_assert(!std::is_assignable<Fn&, RValueCallable>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp
@@ -58,6 +58,8 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_pr34298();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp
@@ -239,8 +239,10 @@
     test_imp<int MemData::*, int(MemData&)>();
 }
 
-int main() {
+int main(int, char**) {
     test_func();
     test_mf();
     test_md();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.fail.cpp
@@ -18,7 +18,9 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f(std::allocator_arg, std::allocator<int>());
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp
@@ -20,10 +20,12 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f(std::allocator_arg, bare_allocator<int>());
     assert(!f);
     }
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
@@ -22,7 +22,9 @@
 
 void foo(int) {}
 
-int main()
+int main(int, char**)
 {
     std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
@@ -106,7 +106,7 @@
     test_MemFunClass<int(MemFunClass::*)(int, int) const, int(MemFunClass&, int, int)>(alloc);
 }
 
-int main()
+int main(int, char**)
 {
     {
         bare_allocator<DummyClass> bare_alloc;
@@ -126,4 +126,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
@@ -21,9 +21,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::function<void(int)> F;
     F f1;
     F f2(std::allocator_arg, std::allocator<int>(), f1);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp
@@ -111,7 +111,7 @@
     test_MemFunClass<int(MemFunClass::*)(int, int) const, int(MemFunClass&, int, int)>(alloc);
 }
 
-int main()
+int main(int, char**)
 {
   {
     bare_allocator<DummyClass> alloc;
@@ -121,4 +121,6 @@
     non_default_test_allocator<DummyClass> alloc(42);
     test_for_alloc(alloc);
   }
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.fail.cpp
@@ -20,7 +20,9 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f(std::allocator_arg, std::allocator<int>(), nullptr);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp
@@ -20,8 +20,10 @@
 
 #include "min_allocator.h"
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f(std::allocator_arg, bare_allocator<int>(), nullptr);
     assert(!f);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.fail.cpp
@@ -50,10 +50,12 @@
 
 int g(int) { return 0; }
 
-int main()
+int main(int, char**)
 {
     {
         std::function<int(int)> f = A();
         std::function<int(int)> f2(std::allocator_arg, std::allocator<A>(), std::move(f));
     }
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
@@ -54,7 +54,7 @@
 
 int g(int) { return 0; }
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -105,4 +105,6 @@
         assert(f2.target<Ptr>());
         assert(f.target<Ptr>()); // f is unchanged because the target is small
     }
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp
@@ -48,7 +48,7 @@
 int g2(int, int) { return 2; }
 int g3(int, int, int) { return 3; }
 
-int main() {
+int main(int, char**) {
   assert(globalMemCounter.checkOutstandingNewEq(0));
   {
     std::function<int(int)> f = A();
@@ -134,4 +134,6 @@
     assert(f.target<int (*)(int)>() == 0);
   }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
@@ -50,7 +50,7 @@
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -161,4 +161,6 @@
         LIBCPP_ASSERT(f.target<Ptr>()); // f is unchanged because the target is small
     }
 #endif  // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp
@@ -15,8 +15,10 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f;
     assert(!f);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp
@@ -33,7 +33,7 @@
 std::function<void()> A::global;
 bool A::cancel = false;
 
-int main()
+int main(int, char**)
 {
   A::global = A();
   assert(A::global.target<A>());
@@ -42,4 +42,6 @@
   A::cancel = true;
   A::global = std::function<void()>(nullptr);
   assert(!A::global.target<A>());
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp
@@ -15,8 +15,10 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::function<int(int)> f(nullptr);
     assert(!f);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp
@@ -46,7 +46,7 @@
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
@@ -68,4 +68,6 @@
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int(*)(int)>() == 0);
     }
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp
@@ -33,7 +33,7 @@
 std::function<void()> A::global;
 bool A::cancel = false;
 
-int main()
+int main(int, char**)
 {
   A::global = A();
   assert(A::global.target<A>());
@@ -42,4 +42,6 @@
   A::cancel = true;
   A::global = nullptr;
   assert(!A::global.target<A>());
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp
@@ -39,7 +39,9 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_int_1();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp
@@ -401,7 +401,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_void_0();
     test_int_0();
@@ -409,4 +409,6 @@
     test_int_1();
     test_void_2();
     test_int_2();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp
@@ -48,7 +48,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER <= 14
     {
@@ -60,4 +60,6 @@
     }
     assert(A::count == 0);
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp
@@ -57,7 +57,7 @@
 int g2(int, int) { return 2; }
 int g3(int, int, int) { return 3; }
 
-int main() {
+int main(int, char**) {
   assert(globalMemCounter.checkOutstandingNewEq(0));
   {
     std::function<int(int)> f1 = A(1);
@@ -189,4 +189,6 @@
   }
   assert(globalMemCounter.checkOutstandingNewEq(0));
   assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
@@ -27,7 +27,7 @@
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f;
@@ -37,4 +37,6 @@
     assert(f != nullptr);
     assert(nullptr != f);
     }
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp
@@ -55,7 +55,7 @@
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f = A();
@@ -89,4 +89,6 @@
     assert(f.target<int>() == nullptr);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp
@@ -47,7 +47,7 @@
 
 int g(int) {return 0;}
 
-int main()
+int main(int, char**)
 {
     {
     std::function<int(int)> f = A();
@@ -57,4 +57,6 @@
     std::function<int(int)> f;
     assert(f.target_type() == typeid(void));
     }
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
@@ -98,10 +98,12 @@
     static_assert((!has_second_argument_type<F>::value), "" );
 }
 
-int main()
+int main(int, char**)
 {
     test_nullary_function<std::function<int()>, int>();
     test_unary_function  <std::function<double(int)>, double, int>();
     test_binary_function <std::function<double(int, char)>, double, int, char>();
     test_other_function  <std::function<double(int, char, double)>, double>();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp
===================================================================
--- test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp
+++ test/std/utilities/function.objects/logical.operations/logical_and.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_and<int> F;
     const F f = F();
@@ -48,4 +48,6 @@
     constexpr bool bar = std::logical_and<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp
===================================================================
--- test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp
+++ test/std/utilities/function.objects/logical.operations/logical_not.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_not<int> F;
     const F f = F();
@@ -38,4 +38,6 @@
     constexpr bool bar = std::logical_not<> () (36);
     static_assert ( !bar, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp
===================================================================
--- test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp
+++ test/std/utilities/function.objects/logical.operations/logical_or.pass.cpp
@@ -16,7 +16,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_or<int> F;
     const F f = F();
@@ -47,4 +47,6 @@
     constexpr bool bar = std::logical_or<> () (36.0, 36);
     static_assert ( bar, "" );
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
===================================================================
--- test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
+++ test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
@@ -22,7 +22,7 @@
 };
 
 
-int main ()
+int main(int, char**)
 {
     static_assert ( !is_transparent<std::logical_and<int>>::value, "" );
     static_assert ( !is_transparent<std::logical_and<std::string>>::value, "" );
Index: test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp
===================================================================
--- test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp
+++ test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp
@@ -28,7 +28,9 @@
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
-int main() {
+int main(int, char**) {
     std::binary_negate<Predicate> f((Predicate())); // expected-error{{'binary_negate<Predicate>' is deprecated}}
     (void)f;
+
+  return 0;
 }
Index: test/std/utilities/function.objects/negators/binary_negate.pass.cpp
===================================================================
--- test/std/utilities/function.objects/negators/binary_negate.pass.cpp
+++ test/std/utilities/function.objects/negators/binary_negate.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::binary_negate<std::logical_and<int> > F;
     const F f = F(std::logical_and<int>());
@@ -25,4 +25,6 @@
     assert( f(36, 0));
     assert( f(0, 36));
     assert( f(0, 0));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp
===================================================================
--- test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp
+++ test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp
@@ -27,6 +27,8 @@
     bool operator()(argument_type) const { return true; }
 };
 
-int main() {
+int main(int, char**) {
     std::not1(Predicate()); // expected-error{{'not1<Predicate>' is deprecated}}
+
+  return 0;
 }
Index: test/std/utilities/function.objects/negators/not1.pass.cpp
===================================================================
--- test/std/utilities/function.objects/negators/not1.pass.cpp
+++ test/std/utilities/function.objects/negators/not1.pass.cpp
@@ -13,9 +13,11 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_not<int> F;
     assert(std::not1(F())(36));
     assert(!std::not1(F())(0));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp
===================================================================
--- test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp
+++ test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp
@@ -28,6 +28,8 @@
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
-int main() {
+int main(int, char**) {
     std::not2(Predicate()); // expected-error{{'not2<Predicate>' is deprecated}}
+
+  return 0;
 }
Index: test/std/utilities/function.objects/negators/not2.pass.cpp
===================================================================
--- test/std/utilities/function.objects/negators/not2.pass.cpp
+++ test/std/utilities/function.objects/negators/not2.pass.cpp
@@ -13,11 +13,13 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::logical_and<int> F;
     assert(!std::not2(F())(36, 36));
     assert( std::not2(F())(36, 0));
     assert( std::not2(F())(0, 36));
     assert( std::not2(F())(0, 0));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp
===================================================================
--- test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp
+++ test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp
@@ -27,7 +27,9 @@
     bool operator()(argument_type) const { return true; }
 };
 
-int main() {
+int main(int, char**) {
     std::unary_negate<Predicate> f((Predicate())); // expected-error{{'unary_negate<Predicate>' is deprecated}}
     (void)f;
+
+  return 0;
 }
Index: test/std/utilities/function.objects/negators/unary_negate.pass.cpp
===================================================================
--- test/std/utilities/function.objects/negators/unary_negate.pass.cpp
+++ test/std/utilities/function.objects/negators/unary_negate.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::unary_negate<std::logical_not<int> > F;
     const F f = F(std::logical_not<int>());
@@ -22,4 +22,6 @@
     static_assert((std::is_same<F::result_type, bool>::value), "" );
     assert(f(36));
     assert(!f(0));
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp
@@ -15,9 +15,11 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::reference_wrapper<const int> r = std::cref(i);
     assert(&r.get() == &i);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp
@@ -15,10 +15,12 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const int i = 0;
     std::reference_wrapper<const int> r1 = std::cref(i);
     std::reference_wrapper<const int> r2 = std::cref(r1);
     assert(&r2.get() == &i);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp
@@ -22,7 +22,9 @@
 
 const A source() {return A();}
 
-int main()
+int main(int, char**)
 {
     std::reference_wrapper<const A> r = std::ref(source());
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp
@@ -15,9 +15,11 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     std::reference_wrapper<int> r = std::ref(i);
     assert(&r.get() == &i);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp
@@ -22,7 +22,7 @@
 template <typename T>
 bool call_pred ( T pred ) { return pred(5); }
 
-int main()
+int main(int, char**)
 {
     {
     int i = 0;
@@ -39,4 +39,6 @@
     assert(call_pred(std::ref(cp)));
     assert(cp.count() == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
@@ -30,7 +30,7 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     void (*fp)() = f;
     test(fp);
@@ -41,4 +41,6 @@
     test(i);
     const int j = 0;
     test(j);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
@@ -42,7 +42,7 @@
     assert(&r2.get() == &f);
 }
 
-int main()
+int main(int, char**)
 {
     void (*fp)() = f;
     test(fp);
@@ -53,4 +53,6 @@
     test(i);
     const int j = 0;
     test(j);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
@@ -30,7 +30,7 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     void (*fp)() = f;
     test(fp);
@@ -41,4 +41,6 @@
     test(i);
     const int j = 0;
     test(j);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp
@@ -17,7 +17,9 @@
 #include <functional>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::reference_wrapper<const int> r(3);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
@@ -29,7 +29,7 @@
 
 void f() {}
 
-int main()
+int main(int, char**)
 {
     void (*fp)() = f;
     test(fp);
@@ -40,4 +40,6 @@
     test(i);
     const int j = 0;
     test(j);
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp
@@ -45,7 +45,9 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_int_1();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp
@@ -319,10 +319,12 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_void_1();
     test_int_1();
     test_void_2();
     testint_2();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp
@@ -69,7 +69,9 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     test_int_0();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp
+++ test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp
@@ -61,7 +61,9 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_void_0();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/type.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/type.pass.cpp
+++ test/std/utilities/function.objects/refwrap/type.pass.cpp
@@ -17,7 +17,7 @@
 
 class C {};
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::reference_wrapper<C>::type,
                                                        C>::value), "");
@@ -33,4 +33,6 @@
                                                        int*(C::*)(double*)>::value), "");
     static_assert((std::is_same<std::reference_wrapper<int (C::*)(double*) const volatile>::type,
                                                        int (C::*)(double*) const volatile>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
+++ test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
@@ -52,7 +52,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<double>();
@@ -60,4 +60,6 @@
 #if TEST_STD_VER >= 11
     test<MoveOnly>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp
+++ test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp
@@ -28,7 +28,7 @@
 
 struct T { };
 
-int main() {
+int main(int, char**) {
   check<T,             T>();
   check<T&,            T>();
   check<T const,       T>();
@@ -54,4 +54,6 @@
   check<std::reference_wrapper<T[3]>&,     T (&)[3]>();
   check<std::reference_wrapper<T ()>,      T (&)()>();
   check<std::reference_wrapper<T ()>&,     T (&)()>();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp
+++ test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp
@@ -39,7 +39,7 @@
 
 struct T { };
 
-int main() {
+int main(int, char**) {
   check<T>();
   check<int>();
   check<float>();
@@ -47,4 +47,6 @@
   check<T*>();
   check<int*>();
   check<float*>();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
+++ test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
@@ -68,7 +68,7 @@
     static const bool value = sizeof(test<T>(0)) == 1;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::reference_wrapper<functor1>::result_type,
                                 char>::value), "");
@@ -93,4 +93,6 @@
     static_assert(has_result_type<std::reference_wrapper<functor3> >::value, "");
     static_assert(!has_result_type<std::reference_wrapper<functor4> >::value, "");
     static_assert(!has_result_type<std::reference_wrapper<C> >::value, "");
+
+  return 0;
 }
Index: test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp
===================================================================
--- test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp
+++ test/std/utilities/function.objects/unord.hash/enabled_hashes.pass.cpp
@@ -17,6 +17,8 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/unord.hash/enum.fail.cpp
===================================================================
--- test/std/utilities/function.objects/unord.hash/enum.fail.cpp
+++ test/std/utilities/function.objects/unord.hash/enum.fail.cpp
@@ -16,8 +16,10 @@
 
 struct X {};
 
-int main()
+int main(int, char**)
 {
     X x;
     size_t h = std::hash<X>{} ( x );
+
+  return 0;
 }
Index: test/std/utilities/function.objects/unord.hash/enum.pass.cpp
===================================================================
--- test/std/utilities/function.objects/unord.hash/enum.pass.cpp
+++ test/std/utilities/function.objects/unord.hash/enum.pass.cpp
@@ -49,7 +49,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<Cardinals>();
 
@@ -59,4 +59,6 @@
     test<EightBitColors>();
 
     test<Fruits>();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/unord.hash/floating.pass.cpp
===================================================================
--- test/std/utilities/function.objects/unord.hash/floating.pass.cpp
+++ test/std/utilities/function.objects/unord.hash/floating.pass.cpp
@@ -64,9 +64,11 @@
     assert(pinf != ninf);
 }
 
-int main()
+int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
+
+  return 0;
 }
Index: test/std/utilities/function.objects/unord.hash/integral.pass.cpp
===================================================================
--- test/std/utilities/function.objects/unord.hash/integral.pass.cpp
+++ test/std/utilities/function.objects/unord.hash/integral.pass.cpp
@@ -46,7 +46,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>();
     test<char>();
@@ -108,4 +108,6 @@
     test<__int128_t>();
     test<__uint128_t>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
===================================================================
--- test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
+++ test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
@@ -22,7 +22,7 @@
 
 struct X {};
 
-int main()
+int main(int, char**)
 {
     using H = std::hash<X>;
     static_assert(!std::is_default_constructible<H>::value, "");
@@ -34,4 +34,6 @@
     static_assert(!std::is_invocable<H, X&>::value, "");
     static_assert(!std::is_invocable<H, X const&>::value, "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
===================================================================
--- test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
+++ test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
@@ -52,8 +52,10 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<int*>();
     test_nullptr();
+
+  return 0;
 }
Index: test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
===================================================================
--- test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
+++ test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp
@@ -21,7 +21,7 @@
 -> decltype ( std::make_tuple ( std::get<I>(t)... ))
 {     return  std::make_tuple ( std::get<I>(t)... ); }
 
-int main()
+int main(int, char**)
 {
 //  Make a couple of sequences
     using int3    = std::make_integer_sequence<int, 3>;     // generates int:    0,1,2
@@ -76,4 +76,6 @@
     auto tsizemix = extract ( tup, sizemix ());
     static_assert ( std::tuple_size<decltype(tsizemix)>::value == sizemix::size (), "tsizemix size wrong");
     assert ( tsizemix == std::make_tuple ( 11, 11, 12, 13, 15 ));
+
+  return 0;
 }
Index: test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
===================================================================
--- test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
+++ test/std/utilities/intseq/intseq.intseq/integer_seq.fail.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER > 11
 
@@ -36,4 +36,6 @@
 X
 
 #endif  // TEST_STD_VER > 11
+
+  return 0;
 }
Index: test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
===================================================================
--- test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
+++ test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp
@@ -22,7 +22,7 @@
 #include <cstddef>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
 //  Make a few of sequences
     using int3    = std::integer_sequence<int, 3, 2, 1>;
@@ -42,4 +42,6 @@
 
     static_assert ( std::is_same<bool0::value_type, bool>::value, "bool0 type wrong" );
     static_assert ( bool0::size() == 0, "bool0 size wrong" );
+
+  return 0;
 }
Index: test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp
===================================================================
--- test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp
+++ test/std/utilities/intseq/intseq.make/make_integer_seq.fail.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   typedef std::make_integer_sequence<int, -3> MakeSeqT;
 
@@ -33,4 +33,6 @@
 #else
     MakeSeqT i; // expected-error@utility:* {{static_assert failed "std::make_integer_sequence must have a non-negative sequence length"}}
 #endif
+
+  return 0;
 }
Index: test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp
===================================================================
--- test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp
+++ test/std/utilities/intseq/intseq.make/make_integer_seq.pass.cpp
@@ -17,7 +17,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_same<std::make_integer_sequence<int, 0>, std::integer_sequence<int>>::value, "");
     static_assert(std::is_same<std::make_integer_sequence<int, 1>, std::integer_sequence<int, 0>>::value, "");
@@ -28,4 +28,6 @@
     static_assert(std::is_same<std::make_integer_sequence<unsigned long long, 1>, std::integer_sequence<unsigned long long, 0>>::value, "");
     static_assert(std::is_same<std::make_integer_sequence<unsigned long long, 2>, std::integer_sequence<unsigned long long, 0, 1>>::value, "");
     static_assert(std::is_same<std::make_integer_sequence<unsigned long long, 3>, std::integer_sequence<unsigned long long, 0, 1, 2>>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/intseq/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/intseq/nothing_to_do.pass.cpp
+++ test/std/utilities/intseq/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp
+++ test/std/utilities/memory/allocator.tag/allocator_arg.pass.cpp
@@ -15,7 +15,9 @@
 
 void test(std::allocator_arg_t) {}
 
-int main()
+int main(int, char**)
 {
     test(std::allocator_arg);
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
@@ -42,9 +42,11 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     A<int> a;
     std::allocator_traits<A<int> >::allocate(a, 10);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::allocator_traits<A<int> >::allocate(a, 10, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
@@ -33,7 +33,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
   {
     A<int> a;
@@ -45,4 +45,6 @@
     Alloc a;
     assert(std::allocator_traits<Alloc >::allocate(a, 10) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
   }
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
@@ -53,7 +53,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
   {
@@ -77,4 +77,6 @@
     Alloc b;
     assert(std::allocator_traits<Alloc >::allocate(b, 11, nullptr) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xFEADBEEF)));
   }
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
@@ -81,7 +81,7 @@
 
 int A2::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A0::count = 0;
@@ -149,4 +149,6 @@
         assert(b_construct == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
@@ -36,7 +36,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
   {
     A<int> a;
@@ -51,4 +51,6 @@
     std::allocator_traits<Alloc >::deallocate(a, reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)), 10);
     assert(called == 1);
   }
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
@@ -54,7 +54,7 @@
 
 int A0::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A0::count = 0;
@@ -86,4 +86,6 @@
         assert(b_destroy == 1);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
@@ -42,7 +42,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         B<int> b;
@@ -74,4 +74,6 @@
         static_assert(noexcept(std::allocator_traits<std::allocator<int>>::max_size(a)) == true, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
@@ -47,7 +47,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
         A<int> a;
@@ -73,4 +73,6 @@
         assert(std::allocator_traits<B<int> >::select_on_container_copy_construction(b).id == 100);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/const_pointer.pass.cpp
@@ -55,7 +55,7 @@
   typedef void const_pointer;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::const_pointer, Ptr<const char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::const_pointer, const char*>::value), "");
@@ -63,4 +63,6 @@
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::const_pointer, const char*>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/const_void_pointer.pass.cpp
@@ -57,7 +57,7 @@
     typedef int const_void_pointer;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::const_void_pointer, Ptr<const void> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::const_void_pointer, const void*>::value), "");
@@ -65,4 +65,6 @@
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::const_void_pointer, const void*>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/difference_type.pass.cpp
@@ -66,7 +66,7 @@
 
 }
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::difference_type, short>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::difference_type, std::ptrdiff_t>::value), "");
@@ -74,4 +74,6 @@
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::difference_type, std::ptrdiff_t>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
@@ -39,7 +39,7 @@
     int not_empty_;  // some random member variable
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::is_always_equal, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::is_always_equal, std::true_type>::value), "");
@@ -48,4 +48,6 @@
     static_assert((std::is_same<std::allocator_traits<A<const char> >::is_always_equal, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<const char> >::is_always_equal, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<C<const char> >::is_always_equal, std::false_type>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/pointer.pass.cpp
@@ -43,11 +43,13 @@
     typedef void pointer;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::pointer, Ptr<char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::pointer, char*>::value), "");
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<C<char> >::pointer, char*>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_copy_assignment.pass.cpp
@@ -43,11 +43,13 @@
     typedef std::true_type propagate_on_container_copy_assignment;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_copy_assignment, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_copy_assignment, std::false_type>::value), "");
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_copy_assignment, std::false_type>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_move_assignment.pass.cpp
@@ -44,11 +44,13 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_move_assignment, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_move_assignment, std::false_type>::value), "");
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_move_assignment, std::false_type>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/propagate_on_container_swap.pass.cpp
@@ -42,11 +42,13 @@
     typedef std::true_type propagate_on_container_swap;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::propagate_on_container_swap, std::true_type>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::propagate_on_container_swap, std::false_type>::value), "");
  #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<C<char> >::propagate_on_container_swap, std::false_type>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/rebind_alloc.pass.cpp
@@ -80,7 +80,7 @@
     };
 };
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_alloc<double>, ReboundA<double> >::value), "");
@@ -97,4 +97,6 @@
     static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_alloc<double>::other, D<double, char> >::value), "");
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_alloc<double>::other, E<double> >::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/size_type.pass.cpp
@@ -62,7 +62,7 @@
 
 }
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::size_type, unsigned short>::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::size_type,
@@ -72,4 +72,6 @@
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::size_type, unsigned short>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator.traits.types/void_pointer.pass.cpp
@@ -56,7 +56,7 @@
     typedef void void_pointer;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::void_pointer, Ptr<void> >::value), "");
     static_assert((std::is_same<std::allocator_traits<B<char> >::void_pointer, void*>::value), "");
@@ -64,4 +64,6 @@
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<D<char> >::void_pointer, void*>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
+++ test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
@@ -24,7 +24,9 @@
     typedef T value_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::allocator_type, A<char> >::value), "");
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
+++ test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
@@ -62,7 +62,7 @@
     template <class U> struct rebind {typedef ReboundA<U> otter;};
 };
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::allocator_traits<A<char> >::rebind_traits<double>, std::allocator_traits<ReboundA<double> > >::value), "");
@@ -77,4 +77,6 @@
     static_assert((std::is_same<std::allocator_traits<D<int, char> >::rebind_traits<double>::other, std::allocator_traits<D<double, char> > >::value), "");
     static_assert((std::is_same<std::allocator_traits<E<char> >::rebind_traits<double>::other, std::allocator_traits<E<double> > >::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.traits/value_type.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.traits/value_type.pass.cpp
+++ test/std/utilities/memory/allocator.traits/value_type.pass.cpp
@@ -24,7 +24,9 @@
     typedef T value_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator_traits<A<char> >::value_type, char>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp
+++ test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
+++ test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
@@ -47,7 +47,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<false, int, std::allocator<int> >();
     test<true, std::vector<int>, std::allocator<int> >();
@@ -71,4 +71,6 @@
 // #if TEST_STD_VER >= 11
 //     static_assert((!std::uses_allocator<E, int>::value), "");
 // #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp
+++ test/std/utilities/memory/allocator.uses/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
+++ test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
@@ -8,6 +8,8 @@
 
 // <cstdlib> and <cstring> are already tested elsewhere
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::allocator<char> AC;
@@ -46,4 +46,6 @@
     (void) a3;
     }
 
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
@@ -21,10 +21,12 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::allocator<int> a1;
     std::allocator<int> a2;
     assert(a1 == a2);
     assert(!(a1 != a2));
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator.members/address.pass.cpp
@@ -31,8 +31,10 @@
     void operator&() const {}
 };
 
-int main()
+int main(int, char**)
 {
     test_address<int>();
     test_address<A>();
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
+++ test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
@@ -19,9 +19,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::allocator<int> a;
     a.allocate(3);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
     a.allocate(3, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
@@ -99,7 +99,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
     test_aligned<1>();
     test_aligned<2>();
     test_aligned<4>();
@@ -108,4 +108,6 @@
     test_aligned<MaxAligned>();
     test_aligned<OverAligned>();
     test_aligned<OverAligned * 2>();
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
@@ -39,8 +39,10 @@
     test_max<T> ((size_t) -1);                     // way too large
 }
 
-int main()
+int main(int, char**)
 {
     test<double>();
     LIBCPP_ONLY(test<const double>());
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
@@ -53,7 +53,7 @@
 };
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     {
     std::allocator<A> a;
@@ -139,4 +139,6 @@
     assert(move_only_constructed == 0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
@@ -18,9 +18,11 @@
 
 int new_called = 0;
 
-int main()
+int main(int, char**)
 {
     const std::allocator<int> a;
     std::size_t M = a.max_size();
     assert(M > 0xFFFF && M <= (std::numeric_limits<std::size_t>::max() / sizeof(int)));
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp
@@ -108,7 +108,7 @@
 
 struct Foo { int x; };
 
-int main()
+int main(int, char**)
 {
     test_pointer<std::allocator<char>> ();
     test_pointer<std::allocator<int>> ();
@@ -117,7 +117,9 @@
     test_void_pointer<std::allocator<char>> ();
     test_void_pointer<std::allocator<int>> ();
     test_void_pointer<std::allocator<Foo>> ();
+
+  return 0;
 }
 #else
-int main() {}
+int main(int, char**) { return 0; }
 #endif
Index: test/std/utilities/memory/default.allocator/allocator_types.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator_types.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator_types.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator<char>::size_type, std::size_t>::value), "");
     static_assert((std::is_same<std::allocator<char>::difference_type, std::ptrdiff_t>::value), "");
@@ -53,4 +53,6 @@
     a2 = a;
     std::allocator<int> a3 = a2;
     ((void)a3);
+
+  return 0;
 }
Index: test/std/utilities/memory/default.allocator/allocator_void.pass.cpp
===================================================================
--- test/std/utilities/memory/default.allocator/allocator_void.pass.cpp
+++ test/std/utilities/memory/default.allocator/allocator_void.pass.cpp
@@ -22,7 +22,7 @@
 #include <memory>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::allocator<void>::pointer, void*>::value), "");
     static_assert((std::is_same<std::allocator<void>::const_pointer, const void*>::value), "");
@@ -32,4 +32,6 @@
     std::allocator<void> a;
     std::allocator<void> a2 = a;
     a2 = a;
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
+++ test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
@@ -99,7 +99,7 @@
 int n = 0;
 static_assert(std::to_address(&n) == &n);
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     ASSERT_NOEXCEPT(std::to_address(&i));
@@ -116,4 +116,6 @@
     P4 p4(&i);
     ASSERT_NOEXCEPT(std::to_address(p4));
     assert(std::to_address(p4) == &i);
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.traits/difference_type.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.traits/difference_type.pass.cpp
+++ test/std/utilities/memory/pointer.traits/difference_type.pass.cpp
@@ -18,7 +18,9 @@
 #include <memory>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<double*>::difference_type, std::ptrdiff_t>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.traits/element_type.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.traits/element_type.pass.cpp
+++ test/std/utilities/memory/pointer.traits/element_type.pass.cpp
@@ -18,7 +18,9 @@
 #include <memory>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<const short*>::element_type, const short>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.traits/pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.traits/pointer.pass.cpp
+++ test/std/utilities/memory/pointer.traits/pointer.pass.cpp
@@ -24,8 +24,10 @@
     typedef char difference_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<A>::pointer, A>::value), "");
     static_assert((std::is_same<std::pointer_traits<int*>::pointer, int*>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp
+++ test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp
@@ -34,7 +34,7 @@
         {return A(&et);}
 };
 
-int main()
+int main(int, char**)
 {
     {
         int i = 0;
@@ -45,4 +45,6 @@
     {
         (std::pointer_traits<A<void> >::element_type)0;
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
+++ test/std/utilities/memory/pointer.traits/pointer.traits.types/difference_type.pass.cpp
@@ -52,7 +52,7 @@
   typedef int difference_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<A>::difference_type, char>::value), "");
     static_assert((std::is_same<std::pointer_traits<B>::difference_type, std::ptrdiff_t>::value), "");
@@ -62,4 +62,6 @@
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::pointer_traits<F<int>>::difference_type, std::ptrdiff_t>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
+++ test/std/utilities/memory/pointer.traits/pointer.traits.types/element_type.pass.cpp
@@ -53,7 +53,7 @@
   typedef int element_type;
 };
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::pointer_traits<A>::element_type, char>::value), "");
     static_assert((std::is_same<std::pointer_traits<B<int> >::element_type, char>::value), "");
@@ -64,4 +64,6 @@
     static_assert((std::is_same<std::pointer_traits<F<double>>::element_type, double>::value), "");
 #endif
 
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
+++ test/std/utilities/memory/pointer.traits/pointer.traits.types/rebind.pass.cpp
@@ -81,7 +81,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::pointer_traits<A<int*> >::rebind<double*>, A<double*> >::value), "");
@@ -101,4 +101,6 @@
     static_assert((std::is_same<std::pointer_traits<D<char, int> >::rebind<double>::other, D1<double, int> >::value), "");
     static_assert((std::is_same<std::pointer_traits<E<char, int> >::rebind<double>::other, E<double, int> >::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp
+++ test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp
@@ -35,9 +35,11 @@
     return true;
 }
 
-int main() {
+int main(int, char**) {
     check();
 #if TEST_STD_VER > 17
     static_assert(check(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/pointer.traits/rebind.pass.cpp
===================================================================
--- test/std/utilities/memory/pointer.traits/rebind.pass.cpp
+++ test/std/utilities/memory/pointer.traits/rebind.pass.cpp
@@ -20,11 +20,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<std::pointer_traits<int*>::rebind<double>, double*>::value), "");
 #else
     static_assert((std::is_same<std::pointer_traits<int*>::rebind<double>::other, double*>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/ptr.align/align.pass.cpp
===================================================================
--- test/std/utilities/memory/ptr.align/align.pass.cpp
+++ test/std/utilities/memory/ptr.align/align.pass.cpp
@@ -13,7 +13,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const unsigned N = 20;
     char buf[N];
@@ -80,4 +80,6 @@
     assert(p == &buf[0]);
     assert(r == nullptr);
     assert(s == N);
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.pass.cpp
@@ -26,7 +26,7 @@
     }
 };
 
-int main()
+int main(int, char**)
 {
     {
     int i;
@@ -47,4 +47,6 @@
     };
     assert(std::addressof(n) == (void*)std::addressof(i));
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
+++ test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
@@ -15,11 +15,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER > 14
     const int *p = std::addressof<const int>(0);
 #else
 #error
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/specialized.addressof/constexpr_addressof.pass.cpp
@@ -32,10 +32,12 @@
 constexpr double d = 0.0;
 constexpr A a{};
 
-int main()
+int main(int, char**)
 {
     static_assert(std::addressof(i) == &i, "");
     static_assert(std::addressof(d) == &d, "");
     constexpr const A* ap = std::addressof(a);
     static_assert(&ap->n == &a.n, "");
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
@@ -30,7 +30,7 @@
 };
 int Counted::count = 0;
 
-int main()
+int main(int, char**)
 {
     using It = forward_iterator<Counted*>;
     const int N = 5;
@@ -43,4 +43,6 @@
     assert(Counted::count == 4);
     std::destroy(It(p), It(p + 4));
     assert(Counted::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp
@@ -41,7 +41,7 @@
     friend void operator&(DCounted) = delete;
 };
 
-int main()
+int main(int, char**)
 {
     {
     void* mem1 = std::malloc(sizeof(Counted));
@@ -74,4 +74,6 @@
     std::free(mem1);
     std::free(mem2);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
@@ -30,7 +30,7 @@
 };
 int Counted::count = 0;
 
-int main()
+int main(int, char**)
 {
     using It = forward_iterator<Counted*>;
     const int N = 5;
@@ -45,4 +45,6 @@
     It it = std::destroy_n(It(p), 4);
     assert(it == It(p+4));
     assert(Counted::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
@@ -103,9 +103,11 @@
     assert(pool[4] == -1);
 }
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_value_initialized();
     test_ctor_throws();
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
@@ -107,9 +107,11 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_value_initialized();
     test_ctor_throws();
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
@@ -102,9 +102,11 @@
     assert(pool[4] == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_value_initialized();
     test_ctor_throws();
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
@@ -107,8 +107,10 @@
     assert(pool[4] == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_value_initialized();
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
@@ -47,7 +47,7 @@
 
 int Nasty::counter_ = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const int N = 5;
@@ -85,4 +85,6 @@
         }
     }
 
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.pass.cpp
@@ -47,7 +47,7 @@
 
 int Nasty::counter_ = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const int N = 5;
@@ -84,4 +84,6 @@
         assert(  p[i].i_ == i);
     }
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.pass.cpp
@@ -46,7 +46,7 @@
 
 int Nasty::counter_ = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const int N = 5;
@@ -84,4 +84,6 @@
     }
 
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.pass.cpp
@@ -47,7 +47,7 @@
 
 int Nasty::counter_ = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const int N = 5;
@@ -81,4 +81,6 @@
     for (int i = 0; i < N; ++i)
         assert(bp[i].i_ == 23);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
@@ -107,7 +107,9 @@
     assert(Counted::count == 0);
 }
 
-int main() {
+int main(int, char**) {
     test_counted();
     test_ctor_throws();
+
+  return 0;
 }
Index: test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
===================================================================
--- test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
+++ test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
@@ -109,8 +109,10 @@
     assert(Counted::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     test_counted();
     test_ctor_throws();
+
+  return 0;
 }
Index: test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
===================================================================
--- test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
+++ test/std/utilities/memory/storage.iterator/raw_storage_iterator.base.pass.cpp
@@ -36,7 +36,7 @@
     A* operator& () DELETE_FUNCTION;
 };
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 14
     typedef std::aligned_storage<3*sizeof(A), std::alignment_of<A>::value>::type
@@ -54,4 +54,6 @@
         assert(it.base() == ap + 1);  // next place to write
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
===================================================================
--- test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
+++ test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp
@@ -36,7 +36,7 @@
     A* operator& () DELETE_FUNCTION;
 };
 
-int main()
+int main(int, char**)
 {
     {
     typedef A S;
@@ -67,4 +67,6 @@
     assert(ap->get() == 1); // original value
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
===================================================================
--- test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
+++ test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
@@ -25,10 +25,12 @@
     int field;
 };
 
-int main()
+int main(int, char**)
 {
     std::pair<A*, std::ptrdiff_t> ip = std::get_temporary_buffer<A>(5);
     assert(!(ip.first == nullptr) ^ (ip.second == 0));
     assert(reinterpret_cast<uintptr_t>(ip.first) % alignof(A) == 0);
     std::return_temporary_buffer(ip.first);
+
+  return 0;
 }
Index: test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp
===================================================================
--- test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp
+++ test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp
@@ -19,10 +19,12 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::pair<int*, std::ptrdiff_t> ip = std::get_temporary_buffer<int>(5);
     assert(ip.first);
     assert(ip.second == 5);
     std::return_temporary_buffer(ip.first);
+
+  return 0;
 }
Index: test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
@@ -26,9 +26,11 @@
 #include "min_allocator.h"
 #include "deleter_types.h"
 
-int main()
+int main(int, char**)
 {
     std::unique_ptr<int, PointerDeleter<int>> p;
     std::ostringstream os;
     os << p; // expected-error {{invalid operands to binary expression}}
+
+  return 0;
 }
Index: test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
@@ -21,11 +21,13 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::unique_ptr<int> p(new int(3));
     std::ostringstream os;
     assert(os.str().empty());
     os << p;
     assert(!os.str().empty());
+
+  return 0;
 }
Index: test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp
===================================================================
--- test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp
+++ test/std/utilities/memory/util.dynamic.safety/declare_no_pointers.pass.cpp
@@ -13,10 +13,12 @@
 
 #include <memory>
 
-int main()
+int main(int, char**)
 {
     char* p = new char[10];
     std::declare_no_pointers(p, 10);
     std::undeclare_no_pointers(p, 10);
     delete [] p;
+
+  return 0;
 }
Index: test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp
===================================================================
--- test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp
+++ test/std/utilities/memory/util.dynamic.safety/declare_reachable.pass.cpp
@@ -14,10 +14,12 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     int* p = new int;
     std::declare_reachable(p);
     assert(std::undeclare_reachable(p) == p);
     delete p;
+
+  return 0;
 }
Index: test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp
===================================================================
--- test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp
+++ test/std/utilities/memory/util.dynamic.safety/get_pointer_safety.pass.cpp
@@ -22,7 +22,7 @@
   assert(d == std::get_pointer_safety());
 }
 
-int main()
+int main(int, char**)
 {
   {
     std::pointer_safety r = std::get_pointer_safety();
@@ -33,4 +33,6 @@
   {
     test_pr26961();
   }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp
+++ test/std/utilities/memory/util.smartptr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.hash/enabled_hash.pass.cpp
@@ -17,6 +17,8 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp
@@ -25,7 +25,7 @@
 struct A {};
 #endif
 
-int main()
+int main(int, char**)
 {
   {
     int* ptr = new int;
@@ -40,4 +40,6 @@
     test_hash_enabled_for_type<std::shared_ptr<A>>();
   }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp
@@ -60,7 +60,7 @@
 
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
   {
     int* ptr = new int;
@@ -99,4 +99,6 @@
 #endif
   }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
@@ -52,7 +52,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {  // https://bugs.llvm.org/show_bug.cgi?id=18843
     std::shared_ptr<T const> t1(new T);
@@ -167,4 +167,6 @@
         assert(my_weak.lock().get() == ptr);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -51,4 +51,6 @@
         assert(*v == 4);
         assert(*w == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -56,4 +56,6 @@
         assert(*v == 4);
         assert(*w == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -51,4 +51,6 @@
         assert(*v == 4);
         assert(*w == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -56,4 +56,6 @@
         assert(*v == 4);
         assert(*w == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -37,4 +37,6 @@
         assert(*p == 3);
         assert(*r == 4);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(4));
@@ -37,4 +37,6 @@
         assert(*p == 3);
         assert(*r == 4);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp
@@ -23,10 +23,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<int> p(new int(3));
         assert(std::atomic_is_lock_free(&p) == false);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp
@@ -28,11 +28,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p(new int(3));
         std::shared_ptr<int> q = std::atomic_load(&p);
         assert(*q == *p);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp
@@ -28,11 +28,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<int> p(new int(3));
         std::shared_ptr<int> q = std::atomic_load_explicit(&p, std::memory_order_relaxed);
         assert(*q == *p);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p;
@@ -36,4 +36,6 @@
         std::atomic_store(&p, r);
         assert(*p == *r);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<int> p;
@@ -36,4 +36,6 @@
         std::atomic_store_explicit(&p, r, std::memory_order_seq_cst);
         assert(*p == *r);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
@@ -22,10 +22,12 @@
 
 struct A;  // purposefully incomplete
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::shared_ptr<A>::element_type, A>::value), "");
 #if TEST_STD_VER > 14
     static_assert((std::is_same<std::shared_ptr<A>::weak_type, std::weak_ptr<A>>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.getdeleter/get_deleter.pass.cpp
@@ -27,7 +27,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         {
@@ -63,4 +63,6 @@
         std::default_delete<A>* d = std::get_deleter<std::default_delete<A> >(p);
         assert(d == 0);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.pass.cpp
@@ -40,7 +40,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::auto_ptr<A> pA(new A);
@@ -110,4 +110,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> pA(new A);
@@ -117,4 +117,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> pA(new A);
@@ -117,4 +117,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_Y_rv.pass.cpp
@@ -41,7 +41,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -119,4 +119,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp
@@ -41,7 +41,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -119,4 +119,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_ptr<A> pA(new A);
@@ -109,4 +109,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/const_pointer_cast.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<const A> pA(new A);
@@ -53,4 +53,6 @@
         assert(pB.get() == pA.get());
         assert(!pB.owner_before(pA) && !pA.owner_before(pB));
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/dynamic_pointer_cast.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<B> pB(new A);
@@ -53,4 +53,6 @@
         assert(pA.get() == 0);
         assert(pA.use_count() == 0);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/static_pointer_cast.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> pA(new A);
@@ -65,4 +65,6 @@
         assert(pB.get() == pA.get());
         assert(!pB.owner_before(pA) && !pA.owner_before(pB));
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp
@@ -40,7 +40,7 @@
 
 void do_nothing(int*) {}
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int(1));
     assert(!(p1 == nullptr));
@@ -65,4 +65,6 @@
     assert(!(nullptr > p2));
     assert( (p2 >= nullptr));
     assert( (nullptr >= p2));
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp
@@ -18,7 +18,7 @@
 
 void do_nothing(int*) {}
 
-int main()
+int main(int, char**)
 {
     int* ptr1(new int);
     int* ptr2(new int);
@@ -27,4 +27,6 @@
     const std::shared_ptr<int> p3(ptr2, do_nothing);
     assert(p1 != p2);
     assert(p2 == p3);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp
@@ -17,7 +17,7 @@
 
 void do_nothing(int*) {}
 
-int main()
+int main(int, char**)
 {
     int* ptr1(new int);
     int* ptr2(new int);
@@ -26,4 +26,6 @@
     const std::shared_ptr<int> p3(ptr2, do_nothing);
     assert((p1 < p2) == (ptr1 < ptr2));
     assert(!(p2 < p3) && !(p3 < p2));
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.pass.cpp
@@ -43,7 +43,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::auto_ptr<A> ptr(new A);
@@ -94,4 +94,6 @@
     assert(A::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
 #endif // !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
@@ -13,9 +13,11 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<int> p;
     assert(p.use_count() == 0);
     assert(p.get() == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t.pass.cpp
@@ -13,9 +13,11 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<int> p(nullptr);
     assert(p.use_count() == 0);
     assert(p.get() == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter.pass.cpp
@@ -27,7 +27,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     std::shared_ptr<A> p(nullptr, test_deleter<A>(3));
@@ -43,4 +43,6 @@
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator.pass.cpp
@@ -27,7 +27,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     std::shared_ptr<A> p(nullptr, test_deleter<A>(3), test_allocator<A>(5));
@@ -81,4 +81,6 @@
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_allocator_throw.pass.cpp
@@ -27,7 +27,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     try
     {
@@ -43,4 +43,6 @@
         assert(test_allocator<A>::count == 0);
         assert(test_allocator<A>::alloc_count == 0);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/nullptr_t_deleter_throw.pass.cpp
@@ -37,7 +37,7 @@
 int A::count = 0;
 
 
-int main()
+int main(int, char**)
 {
     globalMemCounter.throw_after = 0;
     try
@@ -51,4 +51,6 @@
         assert(test_deleter<A>::count == 0);
         assert(test_deleter<A>::dealloc_count == 1);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
@@ -24,7 +24,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     A* ptr = new A;
@@ -42,4 +42,6 @@
     assert(p.get() == ptr);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
@@ -27,7 +27,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     A* ptr = new A;
@@ -44,4 +44,6 @@
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
@@ -28,7 +28,7 @@
 int A::count = 0;
 
 
-int main()
+int main(int, char**)
 {
     {
     A* ptr = new A;
@@ -85,4 +85,6 @@
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator_throw.pass.cpp
@@ -27,7 +27,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     A* ptr = new A;
     try
@@ -44,4 +44,6 @@
         assert(test_allocator<A>::count == 0);
         assert(test_allocator<A>::alloc_count == 0);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp
@@ -34,7 +34,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     A* ptr = new A;
     globalMemCounter.throw_after = 0;
@@ -50,4 +50,6 @@
         assert(test_deleter<A>::dealloc_count == 1);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp
@@ -33,7 +33,7 @@
 int A::count = 0;
 
 
-int main()
+int main(int, char**)
 {
     A* ptr = new A;
     assert(A::count == 1);
@@ -48,4 +48,6 @@
         assert(A::count == 0);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr.pass.cpp
@@ -26,7 +26,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -58,4 +58,6 @@
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y.pass.cpp
@@ -50,7 +50,7 @@
 
 int C::count = 0;
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_convertible<std::shared_ptr<A>, std::shared_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::shared_ptr<B>, std::shared_ptr<A> >::value), "");
@@ -93,4 +93,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
@@ -54,7 +54,7 @@
 
 int C::count = 0;
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_convertible<std::shared_ptr<A>, std::shared_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::shared_ptr<B>, std::shared_ptr<A> >::value), "");
@@ -109,4 +109,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
@@ -37,7 +37,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -57,4 +57,6 @@
     }
     assert(A::count == 0);
     assert(B::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp
@@ -30,7 +30,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> pA(new A);
@@ -73,4 +73,6 @@
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
@@ -49,7 +49,7 @@
 template <typename T>
 void assert_deleter ( T * ) { assert(false); }
 
-int main()
+int main(int, char**)
 {
     {
         std::unique_ptr<A> ptr(new A);
@@ -97,4 +97,6 @@
         std::shared_ptr<int> p2(std::move(p)); // should not call deleter when going out of scope
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.pass.cpp
@@ -40,7 +40,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
@@ -81,4 +81,6 @@
     }
     assert(A::count == 0);
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp
@@ -51,7 +51,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     int i = 67;
@@ -82,4 +82,6 @@
     assert(p->get_char() == 'f');
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_cxx03.pass.cpp
@@ -97,7 +97,7 @@
     assert(Three::count == 0);
 }
 
-int main()
+int main(int, char**)
 {
     {
     int i = 67;
@@ -114,4 +114,6 @@
 #if TEST_STD_VER >= 11
     test<min_allocator<void> >();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
@@ -73,7 +73,7 @@
 void test_pointer_to_function() {}
 #endif // _LIBCPP_VERSION
 
-int main()
+int main(int, char**)
 {
     int nc = globalMemCounter.outstanding_new;
     {
@@ -107,4 +107,6 @@
     }
 #endif
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
@@ -22,7 +22,9 @@
    S () {};  // ctor is private
 };
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<S> p = std::make_shared<S>();
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
@@ -22,7 +22,9 @@
    S () {};  // ctor is protected
 };
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<S> p = std::make_shared<S>();  // expected-error-re@memory:* {{static_assert failed{{.*}} "Can't construct object in make_shared"}}
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.volatile.pass.cpp
@@ -52,9 +52,11 @@
 
 }
 
-int main()
+int main(int, char**)
 {
     test<bool>(true);
     test<int>(3);
     test<double>(5.0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.dest/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.pass.cpp
@@ -18,11 +18,13 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::shared_ptr<int> p(new int(3));
     std::ostringstream os;
     assert(os.str().empty());
     os << p;
     assert(!os.str().empty());
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset.pass.cpp
@@ -38,7 +38,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<B> p(new B);
@@ -58,4 +58,6 @@
         assert(p.get() == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp
@@ -38,7 +38,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<B> p(new B);
@@ -60,4 +60,6 @@
         assert(p.get() == ptr);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<B> p(new B);
@@ -75,4 +75,6 @@
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 2);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp
@@ -40,7 +40,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<B> p(new B);
@@ -84,4 +84,6 @@
     assert(test_deleter<A>::dealloc_count == 2);
     assert(test_allocator<A>::count == 0);
     assert(test_allocator<A>::alloc_count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/swap.pass.cpp
@@ -26,7 +26,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A* ptr1 = new A;
@@ -100,4 +100,6 @@
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/arrow.pass.cpp
@@ -16,7 +16,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<std::pair<int, int> > p(new std::pair<int, int>(3, 4));
     assert(p->first == 3);
@@ -25,4 +25,6 @@
     p->second = 6;
     assert(p->first == 5);
     assert(p->second == 6);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/dereference.pass.cpp
@@ -15,10 +15,12 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p(new int(32));
     assert(*p == 32);
     *p = 3;
     assert(*p == 3);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
@@ -15,7 +15,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     const std::shared_ptr<int> p(new int(32));
@@ -25,4 +25,6 @@
     const std::shared_ptr<int> p;
     assert(!p);
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_shared_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -26,4 +26,6 @@
     assert(p1.owner_before(p3) || p3.owner_before(p1));
     assert(p3.owner_before(p1) == p3.owner_before(p2));
     ASSERT_NOEXCEPT(p1.owner_before(p2));
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/owner_before_weak_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -29,4 +29,6 @@
     assert(p1.owner_before(w3) || p3.owner_before(w1));
     assert(p3.owner_before(w1) == p3.owner_before(w2));
     ASSERT_NOEXCEPT(p1.owner_before(w2));
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/unique.pass.cpp
@@ -15,7 +15,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p(new int(32));
     assert(p.unique());
@@ -24,4 +24,6 @@
     assert(!p.unique());
     }
     assert(p.unique());
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.spec/swap.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.spec/swap.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.spec/swap.pass.cpp
@@ -27,7 +27,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A* ptr1 = new A;
@@ -101,4 +101,6 @@
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/types.pass.cpp
@@ -19,7 +19,9 @@
 
 struct A;  // purposefully incomplete
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::weak_ptr<A>::element_type, A>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
@@ -52,7 +52,7 @@
 
 struct X {};
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -128,4 +128,6 @@
     assert(s.find(vp) == s.end());
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> pA(new A);
@@ -57,4 +57,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> ps(new A);
@@ -74,4 +74,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr_Y.pass.cpp
@@ -39,7 +39,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> ps(new A);
@@ -74,4 +74,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/default.pass.cpp
@@ -17,8 +17,10 @@
 
 struct A;
 
-int main()
+int main(int, char**)
 {
     std::weak_ptr<A> p;
     assert(p.use_count() == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/shared_ptr_Y.pass.cpp
@@ -50,7 +50,7 @@
 
 int C::count = 0;
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_convertible<std::shared_ptr<A>, std::weak_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::weak_ptr<B>, std::shared_ptr<A> >::value), "");
@@ -91,4 +91,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp
@@ -61,7 +61,7 @@
 void sink (std::weak_ptr<T> &&) {}
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         const std::shared_ptr<A> ps(new A);
@@ -112,4 +112,6 @@
     assert(B::count == 0);
     assert(A::count == 0);
 #endif
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
@@ -54,7 +54,7 @@
 template <class T>
 std::weak_ptr<T> source (std::shared_ptr<T> p) { return std::weak_ptr<T>(p); }
 
-int main()
+int main(int, char**)
 {
     static_assert(( std::is_convertible<std::weak_ptr<A>, std::weak_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::weak_ptr<B>, std::weak_ptr<A> >::value), "");
@@ -104,4 +104,6 @@
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.dest/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/reset.pass.cpp
@@ -26,7 +26,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::shared_ptr<A> p1(new A);
@@ -37,4 +37,6 @@
         assert(p1.use_count() == 1);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.mod/swap.pass.cpp
@@ -26,7 +26,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A* ptr1 = new A;
@@ -45,4 +45,6 @@
         }
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/expired.pass.cpp
@@ -26,7 +26,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::weak_ptr<A> wp;
@@ -42,4 +42,6 @@
         assert(wp.use_count() == 0);
         assert(wp.expired() == (wp.use_count() == 0));
     }
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/lock.pass.cpp
@@ -26,7 +26,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         std::weak_ptr<A> wp;
@@ -54,4 +54,6 @@
         assert(A::count == 0);
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/not_less_than.fail.cpp
@@ -15,7 +15,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2(new int);
@@ -23,4 +23,6 @@
     const std::weak_ptr<int> w2(p2);
 
     bool b = w1 < w2;
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -29,4 +29,6 @@
     assert(w1.owner_before(p3) || w3.owner_before(p1));
     assert(w3.owner_before(p1) == w3.owner_before(p2));
     ASSERT_NOEXCEPT(w1.owner_before(p2));
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
@@ -16,7 +16,7 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     const std::shared_ptr<int> p1(new int);
     const std::shared_ptr<int> p2 = p1;
@@ -29,4 +29,6 @@
     assert(w1.owner_before(w3) || w3.owner_before(w1));
     assert(w3.owner_before(w1) == w3.owner_before(w2));
     ASSERT_NOEXCEPT(w1.owner_before(w2));
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.spec/swap.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.spec/swap.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.spec/swap.pass.cpp
@@ -27,7 +27,7 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
         A* ptr1 = new A;
@@ -46,4 +46,6 @@
         }
     }
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp
@@ -20,11 +20,13 @@
 #include <cassert>
 #include <cstring>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_weak_ptr>::value), "");
     std::bad_weak_ptr e;
     std::bad_weak_ptr e2 = e;
     e2 = e;
     assert(std::strcmp(e.what(), "bad_weak_ptr") == 0);
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.help/bool_constant.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.help/bool_constant.pass.cpp
+++ test/std/utilities/meta/meta.help/bool_constant.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER > 14
     typedef std::bool_constant<true> _t;
@@ -30,4 +30,6 @@
     static_assert((std::is_same<_f::type, _f>::value), "");
     static_assert((_f() == false), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.help/integral_constant.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.help/integral_constant.pass.cpp
+++ test/std/utilities/meta/meta.help/integral_constant.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::integral_constant<int, 5> _5;
     static_assert(_5::value == 5, "");
@@ -47,4 +47,6 @@
     std::true_type t1;
     std::true_type t2 = t1;
     assert(t2);
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.logical/conjunction.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.logical/conjunction.pass.cpp
+++ test/std/utilities/meta/meta.logical/conjunction.pass.cpp
@@ -19,7 +19,7 @@
 struct True  { static constexpr bool value = true; };
 struct False { static constexpr bool value = false; };
 
-int main()
+int main(int, char**)
 {
     static_assert ( std::conjunction<>::value, "" );
     static_assert ( std::conjunction<std::true_type >::value, "" );
@@ -62,4 +62,6 @@
 
     static_assert ( std::conjunction_v<True >, "" );
     static_assert (!std::conjunction_v<False>, "" );
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.logical/disjunction.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.logical/disjunction.pass.cpp
+++ test/std/utilities/meta/meta.logical/disjunction.pass.cpp
@@ -19,7 +19,7 @@
 struct True  { static constexpr bool value = true; };
 struct False { static constexpr bool value = false; };
 
-int main()
+int main(int, char**)
 {
     static_assert (!std::disjunction<>::value, "" );
     static_assert ( std::disjunction<std::true_type >::value, "" );
@@ -62,4 +62,6 @@
 
     static_assert ( std::disjunction_v<True >, "" );
     static_assert (!std::disjunction_v<False>, "" );
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.logical/negation.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.logical/negation.pass.cpp
+++ test/std/utilities/meta/meta.logical/negation.pass.cpp
@@ -19,7 +19,7 @@
 struct True  { static constexpr bool value = true; };
 struct False { static constexpr bool value = false; };
 
-int main()
+int main(int, char**)
 {
     static_assert (!std::negation<std::true_type >::value, "" );
     static_assert ( std::negation<std::false_type>::value, "" );
@@ -35,4 +35,6 @@
 
     static_assert ( std::negation<std::negation<std::true_type >>::value, "" );
     static_assert (!std::negation<std::negation<std::false_type>>::value, "" );
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
+++ test/std/utilities/meta/meta.rel/is_base_of.pass.cpp
@@ -40,7 +40,7 @@
 struct B2 : B {};
 struct D : private B1, private B2 {};
 
-int main()
+int main(int, char**)
 {
     test_is_base_of<B, D>();
     test_is_base_of<B1, D>();
@@ -53,4 +53,6 @@
     test_is_not_base_of<B&, D&>();
     test_is_not_base_of<B[3], D[3]>();
     test_is_not_base_of<int, int>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
+++ test/std/utilities/meta/meta.rel/is_convertible.pass.cpp
@@ -60,7 +60,7 @@
   enum { X = T::ThisExpressionWillBlowUp };
 };
 
-int main()
+int main(int, char**)
 {
     // void
     test_is_convertible<void,void> ();
@@ -259,4 +259,6 @@
     // Ensure that CannotInstantiate is not instantiated by is_convertible when it is not needed.
     // For example CannotInstantiate is instatiated as a part of ADL lookup for arguments of type CannotInstantiate*.
     static_assert((std::is_convertible<CannotInstantiate<int>*, CannotInstantiate<int>*>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
+++ test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
@@ -46,7 +46,7 @@
   void operator()(Args&&...) const {}
 };
 
-int main() {
+int main(int, char**) {
   using AbominableFunc = void(...) const;
 
   //  Non-callable things
@@ -241,4 +241,5 @@
   static_assert(std::is_invocable_r_v<void, Fn>, "");
   static_assert(!std::is_invocable_r_v<int, Fn>, "");
 }
+  return 0;
 }
Index: test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
+++ test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
@@ -80,7 +80,7 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   using AbominableFunc = void(...) const noexcept;
   //  Non-callable things
   {
@@ -212,4 +212,6 @@
     static_assert(!std::is_nothrow_invocable_r_v<int, Fn, int>, "");
   }
   test_noexcept_function_pointers();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.rel/is_same.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.rel/is_same.pass.cpp
+++ test/std/utilities/meta/meta.rel/is_same.pass.cpp
@@ -56,7 +56,7 @@
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_same<int, int>();
     test_is_same<void, void>();
@@ -69,4 +69,6 @@
     test_is_not_same<Class, int*>();
     test_is_not_same<int*, int&>();
     test_is_not_same<int&, int>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
+++ test/std/utilities/meta/meta.rqmts/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
@@ -25,7 +25,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_all_extents<int, int> ();
     test_remove_all_extents<const Enum, const Enum> ();
@@ -39,4 +39,6 @@
     test_remove_all_extents<const int[2][3], const int> ();
     test_remove_all_extents<int[1][2][3], int> ();
     test_remove_all_extents<const int[1][2][3], const int> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
@@ -26,7 +26,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test_remove_extent<int, int> ();
     test_remove_extent<const Enum, const Enum> ();
@@ -40,4 +40,6 @@
     test_remove_extent<const int[2][3], const int[3]> ();
     test_remove_extent<int[1][2][3], int[2][3]> ();
     test_remove_extent<const int[1][2][3], const int[2][3]> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
@@ -32,7 +32,7 @@
     test_add_const_imp<const volatile T, const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_add_const<void>();
     test_add_const<int>();
@@ -41,4 +41,6 @@
     test_add_const<const int&>();
     test_add_const<int*>();
     test_add_const<const int*>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
@@ -32,7 +32,7 @@
     test_add_cv_imp<const volatile T, const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_add_cv<void>();
     test_add_cv<int>();
@@ -41,4 +41,6 @@
     test_add_cv<const int&>();
     test_add_cv<int*>();
     test_add_cv<const int*>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
@@ -32,7 +32,7 @@
     test_add_volatile_imp<const volatile T, const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_add_volatile<void>();
     test_add_volatile<int>();
@@ -41,4 +41,6 @@
     test_add_volatile<const int&>();
     test_add_volatile<int*>();
     test_add_volatile<const int*>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
@@ -32,7 +32,7 @@
     test_remove_const_imp<const volatile T, volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_const<void>();
     test_remove_const<int>();
@@ -41,4 +41,6 @@
     test_remove_const<const int&>();
     test_remove_const<int*>();
     test_remove_const<const int*>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
@@ -32,7 +32,7 @@
     test_remove_cv_imp<const volatile T, T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_cv<void>();
     test_remove_cv<int>();
@@ -41,4 +41,6 @@
     test_remove_cv<const int&>();
     test_remove_cv<int*>();
     test_remove_cv<const int*>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
@@ -32,7 +32,7 @@
     test_remove_volatile_imp<const volatile T, const T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_volatile<void>();
     test_remove_volatile<int>();
@@ -41,4 +41,6 @@
     test_remove_volatile<const int&>();
     test_remove_volatile<int*>();
     test_remove_volatile<volatile int*>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
@@ -17,7 +17,7 @@
 #include <cstddef>       // for std::max_align_t
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::aligned_storage<10, 1 >::type T1;
@@ -285,4 +285,6 @@
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 16, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
@@ -16,7 +16,9 @@
 
 class A; // Incomplete
 
-int main()
+int main(int, char**)
 {
     typedef std::aligned_union<10, A>::type T1;
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::aligned_union<10, char >::type T1;
@@ -111,4 +111,6 @@
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 4, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
@@ -234,7 +234,7 @@
 } // namespace note_b_example
 #endif // TEST_STD_VER >= 11
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::common_type<int>::type, int>::value), "");
     static_assert((std::is_same<std::common_type<char>::type, char>::value), "");
@@ -307,4 +307,6 @@
     static_assert((std::is_same<std::common_type<const int, int>::type,       int>::value), "");
     static_assert((std::is_same<std::common_type<int, const int>::type,       int>::value), "");
     static_assert((std::is_same<std::common_type<const int, const int>::type, int>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
@@ -14,7 +14,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::conditional<true, char, int>::type, char>::value), "");
     static_assert((std::is_same<std::conditional<false, char, int>::type, int>::value), "");
@@ -22,4 +22,6 @@
     static_assert((std::is_same<std::conditional_t<true, char, int>, char>::value), "");
     static_assert((std::is_same<std::conditional_t<false, char, int>, int>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
@@ -23,7 +23,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_decay<void, void>();
     test_decay<int, int>();
@@ -38,4 +38,6 @@
     test_decay<int(int)  &, int(int)  &>();
     test_decay<int(int) &&, int(int) &&>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.fail.cpp
@@ -12,7 +12,9 @@
 
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::enable_if<false>::type A;
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
@@ -14,7 +14,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::enable_if<true>::type, void>::value), "");
     static_assert((std::is_same<std::enable_if<true, int>::type, int>::value), "");
@@ -22,4 +22,6 @@
     static_assert((std::is_same<std::enable_if_t<true>, void>::value), "");
     static_assert((std::is_same<std::enable_if_t<true, int>, int>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
@@ -13,7 +13,9 @@
 
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::enable_if_t<false> A;
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
@@ -23,7 +23,7 @@
     static_assert((std::is_same<         std::remove_cvref_t<T>,     U>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_cvref<void, void>();
     test_remove_cvref<int, int>();
@@ -48,4 +48,6 @@
     test_remove_cvref<int(int) volatile, int(int) volatile>();
     test_remove_cvref<int(int)  &, int(int)  &>();
     test_remove_cvref<int(int) &&, int(int) &&>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
@@ -92,7 +92,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     typedef NotDerived ND;
     { // functor object
@@ -366,4 +366,6 @@
 #endif
     test_no_result<PMD(ND&)>();
     }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
@@ -55,7 +55,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef char F::*PMD;
@@ -168,4 +168,6 @@
     test_result_of_imp<int (F::* (std::unique_ptr<const F> ))       () const, int>();
     }
     test_result_of_imp<decltype(&wat::foo)(wat), void>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/type_identity.pass.cpp
@@ -22,7 +22,7 @@
     static_assert((std::is_same<         std::type_identity_t<T>,     T>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test_type_identity<void>();
     test_type_identity<int>();
@@ -36,4 +36,6 @@
     test_type_identity<int(int) volatile>();
     test_type_identity<int(int)  &>();
     test_type_identity<int(int) &&>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
@@ -27,7 +27,7 @@
 enum F { W = UINT_MAX };
 #endif // TEST_UNSIGNED_UNDERLYING_TYPE
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::underlying_type<E>::type, int>::value),
                   "E has the wrong underlying type");
@@ -52,4 +52,6 @@
     static_assert((std::is_same<std::underlying_type_t<G>, char>::value), "");
 #endif // TEST_STD_VER > 11
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
@@ -45,7 +45,7 @@
 
 struct Foo {};
 
-int main()
+int main(int, char**)
 {
     test_add_pointer<void, void*>();
     test_add_pointer<int, int*>();
@@ -76,4 +76,6 @@
     test_function0<void (Foo::*)() const &>();
     test_function0<void (Foo::*)() const &&>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
@@ -22,7 +22,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_pointer<void, void>();
     test_remove_pointer<int, int>();
@@ -40,4 +40,6 @@
     test_remove_pointer<int(*)[3], int[3]>();
     test_remove_pointer<int*&, int*&>();
     test_remove_pointer<const int*&, const int*&>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
@@ -44,7 +44,7 @@
 
 struct Foo {};
 
-int main()
+int main(int, char**)
 {
     test_add_lvalue_reference<void, void>();
     test_add_lvalue_reference<int, int&>();
@@ -75,4 +75,6 @@
     test_function0<void (Foo::*)() const &>();
     test_function0<void (Foo::*)() const &&>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
@@ -46,7 +46,7 @@
 
 struct Foo {};
 
-int main()
+int main(int, char**)
 {
     test_add_rvalue_reference<void, void>();
     test_add_rvalue_reference<int, int&&>();
@@ -73,4 +73,6 @@
     test_function0<void (Foo::*)() &&>();
     test_function0<void (Foo::*)() const &>();
     test_function0<void (Foo::*)() const &&>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
@@ -22,7 +22,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_remove_reference<void, void>();
     test_remove_reference<int, int>();
@@ -43,4 +43,6 @@
     test_remove_reference<int*&&, int*>();
     test_remove_reference<const int*&&, const int*>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
@@ -42,7 +42,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_make_signed< signed char, signed char >();
     test_make_signed< unsigned char, signed char >();
@@ -66,4 +66,6 @@
     test_make_signed< HugeEnum, __int128_t >();
 # endif
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
+++ test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
@@ -42,7 +42,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_make_unsigned<signed char, unsigned char> ();
     test_make_unsigned<unsigned char, unsigned char> ();
@@ -67,4 +67,6 @@
     test_make_unsigned<HugeEnum, __uint128_t>();
 # endif
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
+++ test/std/utilities/meta/meta.trans/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.type.synop/endian.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.type.synop/endian.pass.cpp
+++ test/std/utilities/meta/meta.type.synop/endian.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
     static_assert(std::is_enum<std::endian>::value, "");
 
 // Check that E is a scoped enum by checking for conversions.
@@ -43,4 +43,6 @@
 
     assert ((c[0] == 1) == (std::endian::native == std::endian::big));
     }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp
+++ test/std/utilities/meta/meta.type.synop/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
+++ test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
@@ -39,7 +39,7 @@
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_alignment_of<int&, 4>();
     test_alignment_of<Class, 1>();
@@ -57,4 +57,6 @@
     test_alignment_of<bool, 1>();
 #endif
     test_alignment_of<unsigned, 4>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp
+++ test/std/utilities/meta/meta.unary.prop.query/extent.pass.cpp
@@ -50,7 +50,7 @@
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_extent<void, 0>();
     test_extent<int&, 0>();
@@ -70,4 +70,6 @@
     test_extent1<int[2], 0>();
     test_extent1<int[2][4], 4>();
     test_extent1<int[][4], 4>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
+++ test/std/utilities/meta/meta.unary.prop.query/rank.pass.cpp
@@ -35,7 +35,7 @@
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_rank<void, 0>();
     test_rank<int&, 0>();
@@ -50,4 +50,6 @@
     test_rank<char[3], 1>();
     test_rank<char[][3], 2>();
     test_rank<char[][4][3], 3>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
+++ test/std/utilities/meta/meta.unary.prop.query/void_t.pass.cpp
@@ -45,7 +45,7 @@
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     static_assert( std::is_same<void, std::void_t<>>::value, "");
 
@@ -64,4 +64,6 @@
     test2<void *, int&>();
 
     static_assert( std::is_same<void, std::void_t<int, double const &, Class, volatile int[], void>>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp
+++ test/std/utilities/meta/meta.unary.prop.query/void_t_feature_test_macro.pass.cpp
@@ -27,9 +27,11 @@
 # endif
 #endif
 
-int main()
+int main(int, char**)
 {
 #if defined(__cpp_lib_void_t)
   static_assert(std::is_same_v<std::void_t<int>, void>, "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/array.pass.cpp
@@ -48,7 +48,7 @@
 typedef char incomplete_array[];
 struct Incomplete;
 
-int main()
+int main(int, char**)
 {
     test_array<array>();
     test_array<const_array>();
@@ -57,4 +57,6 @@
 
 //  LWG#2582
     static_assert(!std::is_array<Incomplete>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/class.pass.cpp
@@ -49,11 +49,13 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_class<Class>();
     test_class<incomplete_type>();
 
 //  LWG#2582
     static_assert( std::is_class<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/enum.pass.cpp
@@ -46,10 +46,12 @@
 enum Enum {zero, one};
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_enum<Enum>();
 
 //  LWG#2582
     static_assert(!std::is_enum<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/floating_point.pass.cpp
@@ -45,7 +45,7 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_floating_point<float>();
     test_floating_point<double>();
@@ -53,4 +53,6 @@
 
 //  LWG#2582
     static_assert(!std::is_floating_point<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/function.pass.cpp
@@ -66,7 +66,7 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     TEST_REGULAR( void () );
     TEST_REGULAR( void (int) );
@@ -89,4 +89,6 @@
 
 //  LWG#2582
     static_assert(!std::is_function<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp
@@ -45,7 +45,7 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_integral<bool>();
     test_integral<char>();
@@ -67,4 +67,6 @@
 
 //  LWG#2582
     static_assert(!std::is_integral<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_array.pass.cpp
@@ -70,7 +70,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_array<char[3]>();
     test_is_array<char[]>();
@@ -90,4 +90,6 @@
     test_is_not_array<bit_zero>();
     test_is_not_array<NotEmpty>();
     test_is_not_array<incomplete_type>();  //  LWG#2582
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_class.pass.cpp
@@ -70,7 +70,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_class<Empty>();
     test_is_class<bit_zero>();
@@ -96,4 +96,6 @@
     test_is_not_class<Enum>();
     test_is_not_class<Union>();
     test_is_not_class<FunctionPtr>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_enum.pass.cpp
@@ -70,7 +70,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_enum<Enum>();
 
@@ -91,4 +91,6 @@
     test_is_not_enum<Abstract>();
     test_is_not_enum<FunctionPtr>();
     test_is_not_enum<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_floating_point.pass.cpp
@@ -70,7 +70,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_floating_point<float>();
     test_is_floating_point<double>();
@@ -99,4 +99,6 @@
     test_is_not_floating_point<Enum>();
     test_is_not_floating_point<FunctionPtr>();
     test_is_not_floating_point<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
@@ -74,7 +74,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_function<void(void)>();
     test_is_function<int(int)>();
@@ -105,4 +105,6 @@
   test_is_function<void() noexcept>();
   test_is_function<void() const && noexcept>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_integral.pass.cpp
@@ -71,7 +71,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_integral<short>();
     test_is_integral<unsigned short>();
@@ -105,4 +105,6 @@
     test_is_not_integral<NotEmpty>();
     test_is_not_integral<Abstract>();
     test_is_not_integral<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_lvalue_reference.pass.cpp
@@ -72,7 +72,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_lvalue_reference<int&>();
 
@@ -93,4 +93,6 @@
     test_is_not_lvalue_reference<NotEmpty>();
     test_is_not_lvalue_reference<Abstract>();
     test_is_not_lvalue_reference<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_object_pointer.pass.cpp
@@ -71,7 +71,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_member_object_pointer<int Abstract::*>();
     test_is_member_object_pointer<double NotEmpty::*>();
@@ -95,4 +95,6 @@
     test_is_not_member_object_pointer<NotEmpty>();
     test_is_not_member_object_pointer<Abstract>();
     test_is_not_member_object_pointer<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_member_pointer.pass.cpp
@@ -71,7 +71,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_member_pointer<int Abstract::*>();
     test_is_member_pointer<double NotEmpty::*>();
@@ -102,4 +102,6 @@
   test_is_member_pointer<int (Empty::*)(int, long, long) const noexcept>();
   test_is_member_pointer<int (Empty::*)() & noexcept>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_null_pointer.pass.cpp
@@ -72,7 +72,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_null_pointer<std::nullptr_t>();
 
@@ -93,4 +93,6 @@
     test_is_not_null_pointer<NotEmpty>();
     test_is_not_null_pointer<Abstract>();
     test_is_not_null_pointer<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_pointer.pass.cpp
@@ -70,7 +70,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_pointer<void*>();
     test_is_pointer<int*>();
@@ -92,4 +92,6 @@
     test_is_not_pointer<NotEmpty>();
     test_is_not_pointer<Abstract>();
     test_is_not_pointer<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_rvalue_reference.pass.cpp
@@ -72,7 +72,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_rvalue_reference<int&&>();
 
@@ -93,4 +93,6 @@
     test_is_not_rvalue_reference<NotEmpty>();
     test_is_not_rvalue_reference<Abstract>();
     test_is_not_rvalue_reference<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_union.pass.cpp
@@ -70,7 +70,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_union<Union>();
 
@@ -91,4 +91,6 @@
     test_is_not_union<NotEmpty>();
     test_is_not_union<Abstract>();
     test_is_not_union<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/is_void.pass.cpp
@@ -70,7 +70,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
     test_is_void<void>();
 
@@ -90,4 +90,6 @@
     test_is_not_void<Enum>();
     test_is_not_void<FunctionPtr>();
     test_is_not_void<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/lvalue_ref.pass.cpp
@@ -37,11 +37,13 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_lvalue_ref<int&>();
     test_lvalue_ref<const int&>();
 
 //  LWG#2582
     static_assert(!std::is_lvalue_reference<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer.pass.cpp
@@ -52,7 +52,7 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
   test_member_function_pointer<void (Class::*)()>();
   test_member_function_pointer<void (Class::*)(int)>();
@@ -225,4 +225,6 @@
 
 //  LWG#2582
   static_assert(!std::is_member_function_pointer<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/member_function_pointer_no_variadics.pass.cpp
@@ -51,7 +51,7 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_member_function_pointer<void (Class::*)()>();
     test_member_function_pointer<void (Class::*)(int)>();
@@ -79,4 +79,6 @@
 
 //  LWG#2582
     static_assert(!std::is_member_function_pointer<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/member_object_pointer.pass.cpp
@@ -49,10 +49,12 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_member_object_pointer<int Class::*>();
 
 //  LWG#2582
     static_assert(!std::is_member_object_pointer<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp
@@ -46,13 +46,16 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_nullptr<std::nullptr_t>();
 
 //  LWG#2582
     static_assert(!std::is_null_pointer<incomplete_type>::value, "");
+    return 0;
 }
 #else
-int main() {}
+int main(int, char**) {
+  return 0;
+}
 #endif
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/pointer.pass.cpp
@@ -46,7 +46,7 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_pointer<void*>();
     test_pointer<int*>();
@@ -55,4 +55,6 @@
 
 //  LWG#2582
     static_assert(!std::is_pointer<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/rvalue_ref.pass.cpp
@@ -38,11 +38,13 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_rvalue_ref<int&&>();
     test_rvalue_ref<const int&&>();
 
 //  LWG#2582
     static_assert(!std::is_rvalue_reference<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/union.pass.cpp
@@ -51,10 +51,12 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_union<Union>();
 
 //  LWG#2582
     static_assert(!std::is_union<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.cat/void.pass.cpp
@@ -45,10 +45,12 @@
 
 struct incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_void<void>();
 
 //  LWG#2582
     static_assert(!std::is_void<incomplete_type>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/array.pass.cpp
@@ -39,10 +39,12 @@
 
 class incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_array<array>();
     test_array<const_array>();
     test_array<incomplete_array>();
     test_array<incomplete_type[]>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/class.pass.cpp
@@ -39,8 +39,10 @@
 
 class incomplete_type;
 
-int main()
+int main(int, char**)
 {
     test_class<Class>();
     test_class<incomplete_type>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/enum.pass.cpp
@@ -35,7 +35,9 @@
 
 enum Enum {zero, one};
 
-int main()
+int main(int, char**)
 {
     test_enum<Enum>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/floating_point.pass.cpp
@@ -33,9 +33,11 @@
     test_floating_point_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_floating_point<float>();
     test_floating_point<double>();
     test_floating_point<long double>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/function.pass.cpp
@@ -33,10 +33,12 @@
     test_function_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_function<void ()>();
     test_function<void (int)>();
     test_function<int (double)>();
     test_function<int (double, char)>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp
@@ -33,7 +33,7 @@
     test_integral_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_integral<bool>();
     test_integral<char>();
@@ -52,4 +52,6 @@
     test_integral<__int128_t>();
     test_integral<__uint128_t>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/is_arithmetic.pass.cpp
@@ -72,7 +72,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_arithmetic<short>();
     test_is_arithmetic<unsigned short>();
@@ -103,4 +103,6 @@
     test_is_not_arithmetic<bit_zero>();
     test_is_not_arithmetic<NotEmpty>();
     test_is_not_arithmetic<Abstract>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/is_compound.pass.cpp
@@ -72,7 +72,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_compound<char[3]>();
     test_is_compound<char[]>();
@@ -94,4 +94,6 @@
     test_is_not_compound<void>();
     test_is_not_compound<int>();
     test_is_not_compound<double>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
@@ -72,7 +72,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_fundamental<std::nullptr_t>();
     test_is_fundamental<void>();
@@ -111,4 +111,6 @@
     test_is_not_fundamental<Enum>();
     test_is_not_fundamental<NotEmpty>();
     test_is_not_fundamental<Abstract>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/is_member_pointer.pass.cpp
@@ -72,7 +72,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
 //  Arithmetic types (3.9.1), enumeration types, pointer types, pointer to member types (3.9.2),
 //    std::nullptr_t, and cv-qualified versions of these types (3.9.3)
@@ -101,4 +101,6 @@
     test_is_not_member_pointer<int(int)>();
     test_is_not_member_pointer<Enum>();
     test_is_not_member_pointer<FunctionPtr>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/is_object.pass.cpp
@@ -72,7 +72,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
 // An object type is a (possibly cv-qualified) type that is not a function type,
 // not a reference type, and not a void type.
@@ -99,4 +99,6 @@
     test_is_not_object<int&>();
     test_is_not_object<int&&>();
     test_is_not_object<int(int)>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/is_reference.pass.cpp
@@ -72,7 +72,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
     test_is_reference<int&>();
 #if TEST_STD_VER >= 11
@@ -100,4 +100,6 @@
     test_is_not_reference<int Empty::*>();
     test_is_not_reference<void (Empty::*)(int)>();
 
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/is_scalar.pass.cpp
@@ -72,7 +72,7 @@
 typedef void (*FunctionPtr)();
 
 
-int main()
+int main(int, char**)
 {
 //  Arithmetic types (3.9.1), enumeration types, pointer types, pointer to member types (3.9.2),
 //    std::nullptr_t, and cv-qualified versions of these types (3.9.3)
@@ -110,4 +110,6 @@
     test_is_not_scalar<NotEmpty>();
     test_is_not_scalar<Abstract>();
     test_is_not_scalar<int(int)>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/lvalue_ref.pass.cpp
@@ -24,8 +24,10 @@
     static_assert(!std::is_member_pointer<T>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     test_lvalue_ref<int&>();
     test_lvalue_ref<const int&>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/member_function_pointer.pass.cpp
@@ -37,9 +37,11 @@
 {
 };
 
-int main()
+int main(int, char**)
 {
     test_member_function_pointer<void (Class::*)()>();
     test_member_function_pointer<void (Class::*)(int)>();
     test_member_function_pointer<void (Class::*)(int, char)>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/member_object_pointer.pass.cpp
@@ -37,7 +37,9 @@
 {
 };
 
-int main()
+int main(int, char**)
 {
     test_member_object_pointer<int Class::*>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/pointer.pass.cpp
@@ -33,10 +33,12 @@
     test_pointer_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_pointer<void*>();
     test_pointer<int*>();
     test_pointer<const int*>();
     test_pointer<void (*)(int)>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
@@ -26,8 +26,10 @@
     static_assert(!std::is_member_pointer<T>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     test_rvalue_ref<int&&>();
     test_rvalue_ref<const int&&>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/union.pass.cpp
@@ -39,7 +39,9 @@
     double __;
 };
 
-int main()
+int main(int, char**)
 {
     test_union<Union>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.comp/void.pass.cpp
@@ -33,7 +33,9 @@
     test_void_imp<const volatile T>();
 }
 
-int main()
+int main(int, char**)
 {
     test_void<void>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/has_unique_object_representations.pass.cpp
@@ -80,7 +80,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     test_has_not_has_unique_object_representations<void>();
     test_has_not_has_unique_object_representations<Empty>();
@@ -102,4 +102,6 @@
     test_has_unique_object_representations<char[3]>();
     test_has_unique_object_representations<char[]>();
 
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/has_virtual_destructor.pass.cpp
@@ -70,7 +70,7 @@
     ~A();
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_virtual_destructor<void>();
     test_has_not_virtual_destructor<A>();
@@ -87,4 +87,6 @@
 
     test_has_virtual_destructor<Abstract>();
     test_has_virtual_destructor<NotEmpty>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_abstract.pass.cpp
@@ -72,7 +72,7 @@
 template <>
 struct AbstractTemplate<double> {};
 
-int main()
+int main(int, char**)
 {
     test_is_not_abstract<void>();
     test_is_not_abstract<int&>();
@@ -90,4 +90,6 @@
     test_is_abstract<Abstract>();
     test_is_abstract<AbstractTemplate<int> >();
     test_is_not_abstract<AbstractTemplate<double> >();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_aggregate.pass.cpp
@@ -56,7 +56,7 @@
 struct Union { int x; void* y; };
 
 
-int main ()
+int main(int, char**)
 {
   {
     test_false<void>();
@@ -75,4 +75,6 @@
     test_true<Aggregate[42][101]>();
     test_true<Union>();
   }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
@@ -58,7 +58,7 @@
 template <typename T>
 struct X { T t; };
 
-int main()
+int main(int, char**)
 {
     test_is_assignable<int&, int&> ();
     test_is_assignable<int&, int> ();
@@ -79,4 +79,6 @@
 
 //  pointer to incomplete template type
     test_is_assignable<X<D>*&, X<D>*> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_const.pass.cpp
@@ -30,7 +30,7 @@
 
 struct A; // incomplete
 
-int main()
+int main(int, char**)
 {
     test_is_const<void>();
     test_is_const<int>();
@@ -44,4 +44,6 @@
 
     static_assert(!std::is_const<int&>::value, "");
     static_assert(!std::is_const<const int&>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
@@ -147,7 +147,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     typedef Base B;
     typedef Derived D;
@@ -301,4 +301,6 @@
     test_is_not_constructible<void() &&> ();
 #endif
 #endif // TEST_STD_VER >= 11
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
@@ -63,7 +63,7 @@
     void operator=(C&);  // not const
 };
 
-int main()
+int main(int, char**)
 {
     test_is_copy_assignable<int> ();
     test_is_copy_assignable<int&> ();
@@ -81,4 +81,6 @@
 #endif
     test_is_not_copy_assignable<void> ();
     test_is_not_copy_assignable<C> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
@@ -70,7 +70,7 @@
     void operator=(C&);  // not const
 };
 
-int main()
+int main(int, char**)
 {
     test_is_copy_constructible<A>();
     test_is_copy_constructible<int&>();
@@ -91,4 +91,6 @@
 #if TEST_STD_VER >= 11
     test_is_not_copy_constructible<B>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
@@ -81,7 +81,7 @@
     B();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_default_constructible<A>();
     test_is_default_constructible<Union>();
@@ -122,4 +122,6 @@
     test_is_not_default_constructible<void() &&> ();
 #endif
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
@@ -97,7 +97,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     test_is_destructible<A>();
     test_is_destructible<int&>();
@@ -142,4 +142,6 @@
     test_is_not_destructible<NotEmpty>();
 #endif
 
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_empty.pass.cpp
@@ -78,7 +78,7 @@
     int :  1;
 };
 
-int main()
+int main(int, char**)
 {
     test_is_not_empty<void>();
     test_is_not_empty<int&>();
@@ -100,4 +100,6 @@
     test_is_empty<EmptyBase>();
     test_is_empty<StaticMember>();
     test_is_empty<bit_zero>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp
@@ -48,7 +48,7 @@
 #endif
 }
 
-int main ()
+int main(int, char**)
 {
     test_is_not_final<int>();
     test_is_not_final<int*>();
@@ -58,4 +58,6 @@
     test_is_not_final<U1*>();
     test_is_final    <U2>();
     test_is_not_final<U2*>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
@@ -69,7 +69,7 @@
 
 typedef void (*FunctionPtr)();
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     test_is_literal_type<std::nullptr_t>();
@@ -101,4 +101,6 @@
 
     test_is_not_literal_type<NotEmpty>();
     test_is_not_literal_type<Abstract>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
@@ -53,7 +53,7 @@
     A();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_move_assignable<int> ();
     test_is_move_assignable<A> ();
@@ -68,4 +68,6 @@
     test_is_not_move_assignable<int[3]> ();
 #endif
     test_is_not_move_assignable<void> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
@@ -66,7 +66,7 @@
 #endif
 };
 
-int main()
+int main(int, char**)
 {
     test_is_not_move_constructible<char[3]>();
     test_is_not_move_constructible<char[]>();
@@ -84,4 +84,6 @@
     test_is_move_constructible<NotEmpty>();
     test_is_move_constructible<bit_zero>();
     test_is_move_constructible<B>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
@@ -45,7 +45,7 @@
     void operator=(C&);  // not const
 };
 
-int main()
+int main(int, char**)
 {
     test_is_nothrow_assignable<int&, int&> ();
     test_is_nothrow_assignable<int&, int> ();
@@ -58,4 +58,6 @@
     test_is_not_nothrow_assignable<B, A> ();
     test_is_not_nothrow_assignable<A, B> ();
     test_is_not_nothrow_assignable<C, C&> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
@@ -97,7 +97,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     test_is_nothrow_constructible<int> ();
     test_is_nothrow_constructible<int, const int&> ();
@@ -114,4 +114,6 @@
     static_assert(!std::is_constructible<Tuple&, Empty>::value, "");
     test_is_not_nothrow_constructible<Tuple &, Empty> (); // See bug #19616.
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
@@ -52,7 +52,7 @@
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_nothrow_assign<int&>();
     test_has_nothrow_assign<Union>();
@@ -68,4 +68,6 @@
     test_has_not_nothrow_assign<void>();
     test_has_not_nothrow_assign<A>();
 
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
@@ -55,7 +55,7 @@
     A(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_nothrow_copy_constructor<void>();
     test_has_not_nothrow_copy_constructor<A>();
@@ -68,4 +68,6 @@
     test_is_nothrow_copy_constructible<int*>();
     test_is_nothrow_copy_constructible<const int*>();
     test_is_nothrow_copy_constructible<bit_zero>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
@@ -67,7 +67,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     test_has_not_nothrow_default_constructor<void>();
     test_has_not_nothrow_default_constructor<int&>();
@@ -84,4 +84,6 @@
     test_is_nothrow_default_constructible<const int*>();
     test_is_nothrow_default_constructible<char[3]>();
     test_is_nothrow_default_constructible<bit_zero>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
@@ -79,7 +79,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     test_is_not_nothrow_destructible<void>();
     test_is_not_nothrow_destructible<char[]>();
@@ -110,4 +110,6 @@
     test_is_not_nothrow_destructible<PureProtectedDestructor>();
     test_is_not_nothrow_destructible<PurePrivateDestructor>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
@@ -52,7 +52,7 @@
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_nothrow_assign<int&>();
     test_has_nothrow_assign<Union>();
@@ -66,4 +66,6 @@
 
     test_has_not_nothrow_assign<void>();
     test_has_not_nothrow_assign<A>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
@@ -55,7 +55,7 @@
     A(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_nothrow_move_constructor<void>();
     test_has_not_nothrow_move_constructor<A>();
@@ -68,4 +68,6 @@
     test_is_nothrow_move_constructible<int*>();
     test_is_nothrow_move_constructible<const int*>();
     test_is_nothrow_move_constructible<bit_zero>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable.pass.cpp
@@ -46,7 +46,7 @@
 
 } // namespace MyNS
 
-int main()
+int main(int, char**)
 {
     using namespace MyNS;
     {
@@ -79,4 +79,6 @@
         static_assert(std::is_nothrow_swappable_v<int>, "");
         static_assert(!std::is_nothrow_swappable_v<void>, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
@@ -45,7 +45,7 @@
 
 } // namespace MyNS
 
-int main()
+int main(int, char**)
 {
     using namespace MyNS;
     {
@@ -77,4 +77,6 @@
         static_assert(std::is_nothrow_swappable_with_v<int&, int&>, "");
         static_assert(!std::is_nothrow_swappable_with_v<int&&, int&&>, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_pod.pass.cpp
@@ -49,7 +49,7 @@
     ~Class();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_not_pod<void>();
     test_is_not_pod<int&>();
@@ -61,4 +61,6 @@
     test_is_pod<const int*>();
     test_is_pod<char[3]>();
     test_is_pod<char[]>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
@@ -72,7 +72,7 @@
 };
 #endif
 
-int main()
+int main(int, char**)
 {
     test_is_not_polymorphic<void>();
     test_is_not_polymorphic<int&>();
@@ -91,4 +91,6 @@
 
     test_is_polymorphic<NotEmpty>();
     test_is_polymorphic<Abstract>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp
@@ -51,7 +51,7 @@
 
 struct A; // incomplete
 
-int main()
+int main(int, char**)
 {
     test_is_not_signed<void>();
     test_is_not_signed<int&>();
@@ -71,4 +71,6 @@
     test_is_signed<__int128_t>();
     test_is_not_signed<__uint128_t>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
@@ -50,11 +50,13 @@
     T2 second;
 };
 
-int main()
+int main(int, char**)
 {
     test_is_standard_layout<int> ();
     test_is_standard_layout<int[3]> ();
     test_is_standard_layout<pair<int, double> > ();
 
     test_is_not_standard_layout<int&> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable.pass.cpp
@@ -63,7 +63,7 @@
 
 } // end namespace MyNS2
 
-int main()
+int main(int, char**)
 {
     using namespace MyNS;
     {
@@ -94,4 +94,6 @@
         static_assert(std::is_swappable_v<int>, "");
         static_assert(!std::is_swappable_v<M>, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     // Use a builtin type so we don't get ADL lookup.
     typedef double T[17][29];
@@ -39,4 +39,6 @@
        std::iter_swap(t1, t2);
        std::swap_ranges(t1, t1 + 17, t2);
     }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_with.pass.cpp
@@ -45,7 +45,7 @@
 
 } // namespace MyNS
 
-int main()
+int main(int, char**)
 {
     using namespace MyNS;
     {
@@ -74,4 +74,6 @@
         static_assert(std::is_swappable_with_v<int&, int&>, "");
         static_assert(!std::is_swappable_with_v<D&, C&>, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
@@ -51,7 +51,7 @@
     B();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_trivial<int> ();
     test_is_trivial<A> ();
@@ -59,4 +59,6 @@
     test_is_not_trivial<int&> ();
     test_is_not_trivial<volatile int&> ();
     test_is_not_trivial<B> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
@@ -47,7 +47,7 @@
     void operator=(C&);  // not const
 };
 
-int main()
+int main(int, char**)
 {
     test_is_trivially_assignable<int&, int&> ();
     test_is_trivially_assignable<int&, int> ();
@@ -58,4 +58,6 @@
     test_is_not_trivially_assignable<B, A> ();
     test_is_not_trivially_assignable<A, B> ();
     test_is_not_trivially_assignable<C&, C&> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
@@ -65,7 +65,7 @@
     A(int, double);
 };
 
-int main()
+int main(int, char**)
 {
     test_is_trivially_constructible<int> ();
     test_is_trivially_constructible<int, const int&> ();
@@ -73,4 +73,6 @@
     test_is_not_trivially_constructible<A, int> ();
     test_is_not_trivially_constructible<A, int, double> ();
     test_is_not_trivially_constructible<A> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
@@ -59,7 +59,7 @@
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_trivially_copy_assignable<int&>();
     test_has_trivially_copy_assignable<Union>();
@@ -76,4 +76,6 @@
     test_has_not_trivially_copy_assignable<Abstract>();
     test_has_not_trivially_copy_assignable<const Empty>();
 
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
@@ -65,7 +65,7 @@
     A(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_trivial_copy_constructor<void>();
     test_has_not_trivial_copy_constructor<A>();
@@ -80,4 +80,6 @@
     test_is_trivially_copy_constructible<int*>();
     test_is_trivially_copy_constructible<const int*>();
     test_is_trivially_copy_constructible<bit_zero>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copyable.pass.cpp
@@ -65,7 +65,7 @@
     C();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_trivially_copyable<int> ();
     test_is_trivially_copyable<const int> ();
@@ -76,4 +76,6 @@
     test_is_not_trivially_copyable<int&> ();
     test_is_not_trivially_copyable<const A&> ();
     test_is_not_trivially_copyable<B> ();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
@@ -69,7 +69,7 @@
     A();
 };
 
-int main()
+int main(int, char**)
 {
     test_has_not_trivial_default_constructor<void>();
     test_has_not_trivial_default_constructor<int&>();
@@ -85,4 +85,6 @@
     test_is_trivially_default_constructible<const int*>();
     test_is_trivially_default_constructible<char[3]>();
     test_is_trivially_default_constructible<bit_zero>();
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
@@ -87,7 +87,7 @@
     ~A();
 };
 
-int main()
+int main(int, char**)
 {
     test_is_not_trivially_destructible<void>();
     test_is_not_trivially_destructible<A>();
@@ -115,4 +115,6 @@
     test_is_not_trivially_destructible<PureProtectedDestructor>();
     test_is_not_trivially_destructible<PurePrivateDestructor>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
@@ -59,7 +59,7 @@
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
     test_has_trivial_assign<int&>();
     test_has_trivial_assign<Union>();
@@ -76,4 +76,6 @@
     test_has_not_trivial_assign<Abstract>();
     test_has_not_trivial_assign<const Empty>();
 
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
@@ -75,7 +75,7 @@
 
 #endif
 
-int main()
+int main(int, char**)
 {
     test_has_not_trivial_move_constructor<void>();
     test_has_not_trivial_move_constructor<A>();
@@ -94,4 +94,6 @@
     static_assert(!std::is_trivially_move_constructible<MoveOnly1>::value, "");
     static_assert( std::is_trivially_move_constructible<MoveOnly2>::value, "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp
@@ -51,7 +51,7 @@
 
 struct A; // incomplete
 
-int main()
+int main(int, char**)
 {
     test_is_not_unsigned<void>();
     test_is_not_unsigned<int&>();
@@ -71,4 +71,6 @@
     test_is_unsigned<__uint128_t>();
     test_is_not_unsigned<__int128_t>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
+++ test/std/utilities/meta/meta.unary/meta.unary.prop/is_volatile.pass.cpp
@@ -30,7 +30,7 @@
 
 struct A; // incomplete
 
-int main()
+int main(int, char**)
 {
     test_is_volatile<void>();
     test_is_volatile<int>();
@@ -44,4 +44,6 @@
 
     static_assert(!std::is_volatile<int&>::value, "");
     static_assert(!std::is_volatile<volatile int&>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp
+++ test/std/utilities/meta/meta.unary/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/nothing_to_do.pass.cpp
+++ test/std/utilities/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp
+++ test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp
@@ -17,9 +17,11 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
 
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.hash/hash.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.hash/hash.pass.cpp
+++ test/std/utilities/optional/optional.hash/hash.pass.cpp
@@ -30,7 +30,7 @@
 
 }
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     const std::size_t nullopt_hash =
@@ -76,4 +76,6 @@
       test_hash_enabled_for_type<std::optional<B>>();
       test_hash_enabled_for_type<std::optional<const B>>();
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
+++ test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp
@@ -23,8 +23,10 @@
 #include <optional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     using std::bad_optional_access;
     bad_optional_access ex;
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
+++ test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
@@ -23,10 +23,12 @@
 #include <optional>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     using std::bad_optional_access;
 
     static_assert(std::is_base_of<std::exception, bad_optional_access>::value, "");
     static_assert(std::is_convertible<bad_optional_access*, std::exception*>::value, "");
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp
+++ test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp
@@ -26,7 +26,7 @@
   return lhs.i_ == rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -60,4 +60,6 @@
     static_assert(o1 == 42, "");
     static_assert(!(101 == o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp
+++ test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp
@@ -24,7 +24,7 @@
 
 constexpr bool operator>(const X& lhs, const X& rhs) { return lhs.i_ > rhs.i_; }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -60,4 +60,6 @@
     static_assert(o1 > 11, "");
     static_assert(!(42 > o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
+++ test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
@@ -26,7 +26,7 @@
   return lhs.i_ >= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -62,4 +62,6 @@
     static_assert(o1 >= 42, "");
     static_assert(!(11 >= o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
+++ test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
@@ -26,7 +26,7 @@
   return lhs.i_ <= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -62,4 +62,6 @@
     static_assert(o1 <= 42, "");
     static_assert(!(101 <= o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp
+++ test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp
@@ -24,7 +24,7 @@
 
 constexpr bool operator<(const X& lhs, const X& rhs) { return lhs.i_ < rhs.i_; }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -60,4 +60,6 @@
     static_assert(o1 < 101, "");
     static_assert(!(42 < o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
+++ test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
@@ -26,7 +26,7 @@
   return lhs.i_ != rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -60,4 +60,6 @@
     static_assert(o1 != 101, "");
     static_assert(!(42 != o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.nullops/equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.nullops/equal.pass.cpp
+++ test/std/utilities/optional/optional.nullops/equal.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@
     static_assert (noexcept(nullopt == o1), "");
     static_assert (noexcept(o1 == nullopt), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.nullops/greater.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.nullops/greater.pass.cpp
+++ test/std/utilities/optional/optional.nullops/greater.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@
     static_assert (noexcept(nullopt > o1), "");
     static_assert (noexcept(o1 > nullopt), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp
+++ test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@
     static_assert (noexcept(nullopt >= o1), "");
     static_assert (noexcept(o1 >= nullopt), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.nullops/less_equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.nullops/less_equal.pass.cpp
+++ test/std/utilities/optional/optional.nullops/less_equal.pass.cpp
@@ -15,7 +15,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -36,4 +36,6 @@
     static_assert (noexcept(nullopt <= o1), "");
     static_assert (noexcept(o1 <= nullopt), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.nullops/less_than.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.nullops/less_than.pass.cpp
+++ test/std/utilities/optional/optional.nullops/less_than.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@
     static_assert (noexcept(nullopt < o1), "");
     static_assert (noexcept(o1 < nullopt), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.nullops/not_equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.nullops/not_equal.pass.cpp
+++ test/std/utilities/optional/optional.nullops/not_equal.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -35,4 +35,6 @@
     static_assert (noexcept(nullopt != o1), "");
     static_assert (noexcept(o1 != nullopt), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
===================================================================
--- test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
+++ test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
@@ -18,7 +18,9 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     std::nullopt_t n = {};
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
+++ test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
@@ -29,11 +29,13 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_empty_v<nullopt_t>);
     static_assert(!std::is_default_constructible_v<nullopt_t>);
 
     static_assert(std::is_same_v<const nullopt_t, decltype(nullopt)>);
     static_assert(test());
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
@@ -241,7 +241,7 @@
 
 using Fn = void(*)();
 
-int main()
+int main(int, char**)
 {
     test_sfinae();
     // Test with instrumented type
@@ -268,4 +268,6 @@
         assert(**opt == 3);
     }
     test_throws();
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp
@@ -196,7 +196,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test_with_test_type();
     test_ambigious_assign();
@@ -250,4 +250,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
@@ -48,7 +48,7 @@
     return lhs.has_value() && rhs.has_value() && *lhs == *rhs;
 }
 
-int main()
+int main(int, char**)
 {
     {
         using O = optional<int>;
@@ -102,4 +102,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp
@@ -208,7 +208,7 @@
 
 
 
-int main()
+int main(int, char**)
 {
     {
         test_on_test_type<TestTypes::TestType>();
@@ -265,4 +265,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp
@@ -69,7 +69,7 @@
 
 bool Z::dtor_called = false;
 
-int main()
+int main(int, char**)
 {
     {
         X x;
@@ -117,4 +117,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -66,7 +66,7 @@
     return lhs.has_value() && rhs.has_value() && *lhs == Tp{101};
 }
 
-int main()
+int main(int, char**)
 {
     {
         static_assert(std::is_nothrow_move_assignable<optional<int>>::value, "");
@@ -204,4 +204,5 @@
         };
         static_assert(std::is_nothrow_move_assignable<optional<NoThrowMove>>::value, "");
     }
+    return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp
@@ -22,7 +22,7 @@
 using std::nullopt_t;
 using std::nullopt;
 
-int main()
+int main(int, char**)
 {
     {
         optional<int> opt;
@@ -63,4 +63,6 @@
     assert(TT::alive == 0);
     assert(TT::destroyed == 1);
     TT::reset();
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp
@@ -201,7 +201,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test_with_test_type();
     test_ambigious_assign();
@@ -264,4 +264,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
@@ -153,7 +153,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
     test_implicit();
     test_explicit();
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
@@ -29,7 +29,7 @@
 
 using std::optional;
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -132,4 +132,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
@@ -78,7 +78,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef short U;
@@ -130,4 +130,6 @@
     }
 
     static_assert(!(std::is_constructible<optional<X>, const optional<Y>&>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -113,7 +113,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<int>(3);
@@ -169,4 +169,6 @@
         constexpr std::optional<int> o2 = o1;
         static_assert( *o2 == 4, "" );
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/deduct.fail.cpp
@@ -23,7 +23,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
 
@@ -42,4 +42,6 @@
 //  optional(nullopt_t)
     std::optional opt(std::nullopt);   // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with nullopt_t is ill-formed"}}
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
@@ -23,7 +23,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
@@ -50,4 +50,6 @@
     assert(static_cast<bool>(opt) == static_cast<bool>(source));
     assert(*opt == *source);
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
@@ -61,7 +61,7 @@
     };
 }
 
-int main()
+int main(int, char**)
 {
     test_constexpr<optional<int>>();
     test_constexpr<optional<int*>>();
@@ -77,4 +77,6 @@
     test_constexpr<optional<NonLiteralTypes::NoCtors&>>();
     test_constexpr<optional<NonLiteralTypes::NoCtors&&>>();
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
@@ -79,7 +79,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef X T;
@@ -117,4 +117,6 @@
         optional<U> rhs(3);
         test<T>(rhs, true);
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
@@ -62,7 +62,7 @@
     explicit Z(int) { TEST_THROW(6); }
 };
 
-int main()
+int main(int, char**)
 {
     {
         optional<int> rhs;
@@ -80,4 +80,6 @@
         optional<int> rhs(3);
         test<Z>(std::move(rhs), true);
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
@@ -58,7 +58,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         constexpr optional<int> opt(in_place, 5);
@@ -144,4 +144,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
@@ -66,7 +66,7 @@
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         static_assert(!std::is_constructible<X, std::initializer_list<int>&>::value, "");
@@ -112,4 +112,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
@@ -28,9 +28,11 @@
     };
 
 
-int main()
+int main(int, char**)
 {
     static_assert (!std::is_trivially_move_constructible_v<S>, "" );
     constexpr std::optional<S> o1;
     constexpr std::optional<S> o2 = std::move(o1);  // not constexpr
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -151,7 +151,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<int>(3);
@@ -225,4 +225,6 @@
     constexpr std::optional<int> o2 = std::move(o1);
     static_assert( *o2 == 4, "" );
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
@@ -61,7 +61,7 @@
     };
 }
 
-int main()
+int main(int, char**)
 {
     test_constexpr<optional<int>>();
     test_constexpr<optional<int*>>();
@@ -69,4 +69,6 @@
     test_constexpr<optional<NonTrivialTypes::NoCtors>>();
     test_constexpr<optional<NonConstexprTypes::NoCtors>>();
     test<optional<NonLiteralTypes::NoCtors>>();
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
@@ -61,7 +61,7 @@
     Z(int) { TEST_THROW(6); }
 };
 
-int main()
+int main(int, char**)
 {
     {
         optional<short> rhs;
@@ -89,4 +89,6 @@
     }
 
     static_assert(!(std::is_constructible<optional<X>, optional<Z>>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
@@ -39,7 +39,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -157,4 +157,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp
@@ -32,7 +32,7 @@
 
 bool X::dtor_called = false;
 
-int main()
+int main(int, char**)
 {
     {
         typedef int T;
@@ -64,4 +64,6 @@
         }
         assert(X::dtor_called == true);
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
@@ -26,7 +26,7 @@
 
 bool X::dtor_called = false;
 
-int main()
+int main(int, char**)
 {
     {
         optional<int> opt;
@@ -55,4 +55,6 @@
         assert(static_cast<bool>(opt) == false);
         X::dtor_called = false;
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     {
@@ -33,4 +33,6 @@
         constexpr optional<int> opt(0);
         static_assert(opt, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
@@ -43,7 +43,7 @@
     return (*opt).test();
 }
 
-int main()
+int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
@@ -69,4 +69,6 @@
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
@@ -36,7 +36,7 @@
     int test() const {return 2;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
@@ -65,4 +65,6 @@
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
@@ -36,7 +36,7 @@
     int test() const && {return 2;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
@@ -65,4 +65,6 @@
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
@@ -43,7 +43,7 @@
     return (*std::move(opt)).test();
 }
 
-int main()
+int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
@@ -69,4 +69,6 @@
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     {
@@ -33,4 +33,6 @@
         constexpr optional<int> opt(0);
         static_assert(opt.has_value(), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp
@@ -40,7 +40,7 @@
     return opt->test();
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::optional<X> opt; ((void)opt);
@@ -68,4 +68,6 @@
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp
@@ -39,7 +39,7 @@
     constexpr int test() const {return 1;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const std::optional<X> opt; ((void)opt);
@@ -72,4 +72,6 @@
         assert(false);
     }
 #endif  // _LIBCPP_DEBUG
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
@@ -52,7 +52,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
@@ -78,4 +78,6 @@
     }
 #endif
     static_assert(test() == 7, "");
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp
@@ -23,10 +23,12 @@
     int test() {return 4;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         constexpr optional<X> opt;
         static_assert(opt.value().test() == 3, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
@@ -41,7 +41,7 @@
     int test() && {return 6;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
@@ -69,4 +69,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
@@ -41,7 +41,7 @@
     int test() && {return 6;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         const optional<X> opt; ((void)opt);
@@ -69,4 +69,6 @@
         }
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
@@ -67,7 +67,9 @@
     return 0;
 }
 
-int main()
+int main(int, char**)
 {
     static_assert(test() == 0);
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp
@@ -35,7 +35,7 @@
         {return x.i_ == y.i_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         constexpr optional<X> opt(2);
@@ -73,4 +73,6 @@
         const optional<X> opt;
         assert(opt.value_or(Y(3)) == 4);
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
@@ -50,7 +50,7 @@
     return std::move(opt).value().test();
 }
 
-int main()
+int main(int, char**)
 {
     {
         optional<X> opt; ((void)opt);
@@ -76,4 +76,6 @@
     }
 #endif
     static_assert(test() == 7, "");
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp
+++ test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp
@@ -64,7 +64,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         optional<int> opt1;
@@ -302,4 +302,6 @@
         assert(*opt2 == 2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
===================================================================
--- test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
+++ test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
@@ -21,7 +21,7 @@
     ~X() {}
 };
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     {
@@ -46,4 +46,6 @@
     }
     // FIXME these are garbage diagnostics that Clang should not produce
     // expected-error@optional:* 0+ {{is not a base class}}
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.object/special_members.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/special_members.pass.cpp
+++ test/std/utilities/optional/optional.object/special_members.pass.cpp
@@ -52,11 +52,12 @@
     DoTestsMetafunction() { sink(SpecialMemberTest<TestTypes>{}...); }
 };
 
-int main() {
+int main(int, char**) {
     sink(
         ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
         ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
         NonLiteralTypes::ApplyTypes<DoTestsMetafunction>{},
         NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{}
     );
+    return 0;
 }
Index: test/std/utilities/optional/optional.object/triviality.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/triviality.pass.cpp
+++ test/std/utilities/optional/optional.object/triviality.pass.cpp
@@ -85,7 +85,7 @@
     TrivialCopyNonTrivialMove& operator=(TrivialCopyNonTrivialMove&&) { return *this; }
 };
 
-int main() {
+int main(int, char**) {
     sink(
         ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
         ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
@@ -93,4 +93,5 @@
         NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{},
         DoTestsMetafunction<TrivialMoveNonTrivialCopy, TrivialCopyNonTrivialMove>{}
     );
+    return 0;
 }
Index: test/std/utilities/optional/optional.object/types.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.object/types.pass.cpp
+++ test/std/utilities/optional/optional.object/types.pass.cpp
@@ -28,10 +28,12 @@
     static_assert(std::is_same<typename Opt::value_type, T>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     test<optional<int>, int>();
     test<optional<const int>, const int>();
     test<optional<double>, double>();
     test<optional<const double>, const double>();
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.relops/equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.relops/equal.pass.cpp
+++ test/std/utilities/optional/optional.relops/equal.pass.cpp
@@ -27,7 +27,7 @@
   return lhs.i_ == rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -82,4 +82,6 @@
     static_assert(o1 == O2(42), "");
     static_assert(!(O2(101) == o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.relops/greater_equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.relops/greater_equal.pass.cpp
+++ test/std/utilities/optional/optional.relops/greater_equal.pass.cpp
@@ -25,7 +25,7 @@
   return lhs.i_ >= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef optional<X> O;
 
@@ -79,4 +79,6 @@
     static_assert(o1 >= O2(42), "");
     static_assert(!(O2(1) >= o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.relops/greater_than.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.relops/greater_than.pass.cpp
+++ test/std/utilities/optional/optional.relops/greater_than.pass.cpp
@@ -23,7 +23,7 @@
 
 constexpr bool operator>(const X& lhs, const X& rhs) { return lhs.i_ > rhs.i_; }
 
-int main() {
+int main(int, char**) {
   {
     typedef optional<X> O;
 
@@ -77,4 +77,6 @@
     static_assert(o1 > O2(1), "");
     static_assert(!(O2(42) > o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.relops/less_equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.relops/less_equal.pass.cpp
+++ test/std/utilities/optional/optional.relops/less_equal.pass.cpp
@@ -25,7 +25,7 @@
   return lhs.i_ <= rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef optional<X> O;
 
@@ -79,4 +79,6 @@
     static_assert(o1 <= O2(42), "");
     static_assert(!(O2(101) <= o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.relops/less_than.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.relops/less_than.pass.cpp
+++ test/std/utilities/optional/optional.relops/less_than.pass.cpp
@@ -23,7 +23,7 @@
 
 constexpr bool operator<(const X& lhs, const X& rhs) { return lhs.i_ < rhs.i_; }
 
-int main() {
+int main(int, char**) {
   {
     typedef optional<X> O;
 
@@ -77,4 +77,6 @@
     static_assert(o1 < O2(101), "");
     static_assert(!(O2(101) < o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.relops/not_equal.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.relops/not_equal.pass.cpp
+++ test/std/utilities/optional/optional.relops/not_equal.pass.cpp
@@ -27,7 +27,7 @@
   return lhs.i_ != rhs.i_;
 }
 
-int main() {
+int main(int, char**) {
   {
     typedef X T;
     typedef optional<T> O;
@@ -82,4 +82,6 @@
     static_assert(o1 != O2(101), "");
     static_assert(!(O2(42) != o1), "");
   }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
+++ test/std/utilities/optional/optional.specalg/make_optional.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::make_optional;
@@ -55,4 +55,6 @@
         assert(**opt == 3);
         assert(s == nullptr);
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp
+++ test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp
@@ -17,7 +17,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::make_optional;
@@ -41,4 +41,6 @@
         auto opt = make_optional<std::string>(4, 'X');
         assert(*opt == "XXXX");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp
+++ test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp
@@ -27,7 +27,7 @@
       : x(*il.begin()), size(static_cast<int>(il.size())) {}
 };
 
-int main()
+int main(int, char**)
 {
     using std::make_optional;
     {
@@ -49,4 +49,6 @@
         auto opt = make_optional<std::string>({'a', 'b', 'c'}, std::allocator<char>{});
         assert(*opt == "abc");
     }
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.specalg/swap.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.specalg/swap.pass.cpp
+++ test/std/utilities/optional/optional.specalg/swap.pass.cpp
@@ -109,7 +109,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_swap_sfinae();
     {
@@ -348,4 +348,6 @@
         assert(*opt2 == 2);
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp
===================================================================
--- test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp
+++ test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::in_place_t;
@@ -22,4 +22,6 @@
 
     optional<in_place_t> opt; // expected-note {{requested here}}
     // expected-error@optional:* {{"instantiation of optional with in_place_t is ill-formed"}}
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
===================================================================
--- test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
+++ test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
@@ -13,10 +13,12 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
 
     std::initializer_list<int> list;
     (void)list;
+
+  return 0;
 }
Index: test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp
===================================================================
--- test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp
+++ test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp
@@ -14,7 +14,7 @@
 
 #include <optional>
 
-int main()
+int main(int, char**)
 {
     using std::optional;
     using std::nullopt_t;
@@ -25,4 +25,6 @@
     optional<nullopt_t &> opt2; // expected-note 1 {{requested here}}
     optional<nullopt_t &&> opt3; // expected-note 1 {{requested here}}
     // expected-error@optional:* 4 {{instantiation of optional with nullopt_t is ill-formed}}
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp
===================================================================
--- test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp
+++ test/std/utilities/ratio/ratio.arithmetic/ratio_add.fail.cpp
@@ -10,9 +10,11 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     typedef std::ratio<0x7FFFFFFFFFFFFFFFLL, 1> R1;
     typedef std::ratio<1, 1> R2;
     typedef std::ratio_add<R1, R2>::type R;
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp
+++ test/std/utilities/ratio/ratio.arithmetic/ratio_add.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -72,4 +72,6 @@
     typedef std::ratio_add<R1, R2>::type R;
     static_assert(R::num == 1 && R::den == 1, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp
===================================================================
--- test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp
+++ test/std/utilities/ratio/ratio.arithmetic/ratio_divide.fail.cpp
@@ -10,9 +10,11 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     typedef std::ratio<0x7FFFFFFFFFFFFFFFLL, 1> R1;
     typedef std::ratio<1, 2> R2;
     typedef std::ratio_divide<R1, R2>::type R;
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp
+++ test/std/utilities/ratio/ratio.arithmetic/ratio_divide.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -54,4 +54,6 @@
     typedef std::ratio_divide<R1, R2>::type R;
     static_assert(R::num == 630992477165LL && R::den == 127339199162436LL, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp
===================================================================
--- test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp
+++ test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.fail.cpp
@@ -10,9 +10,11 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     typedef std::ratio<0x7FFFFFFFFFFFFFFFLL, 1> R1;
     typedef std::ratio<2, 1> R2;
     typedef std::ratio_multiply<R1, R2>::type R;
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp
+++ test/std/utilities/ratio/ratio.arithmetic/ratio_multiply.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -54,4 +54,6 @@
     typedef std::ratio_multiply<R1, R2>::type R;
     static_assert(R::num == 15519594064236LL && R::den == 5177331081415LL, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp
===================================================================
--- test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp
+++ test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.fail.cpp
@@ -10,9 +10,11 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     typedef std::ratio<-0x7FFFFFFFFFFFFFFFLL, 1> R1;
     typedef std::ratio<1, 1> R2;
     typedef std::ratio_subtract<R1, R2>::type R;
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp
+++ test/std/utilities/ratio/ratio.arithmetic/ratio_subtract.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -72,4 +72,6 @@
     typedef std::ratio_subtract<R1, R2>::type R;
     static_assert(R::num == -1 && R::den == 1, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp
+++ test/std/utilities/ratio/ratio.comparison/ratio_equal.pass.cpp
@@ -21,7 +21,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, false>();
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp
+++ test/std/utilities/ratio/ratio.comparison/ratio_greater.pass.cpp
@@ -21,7 +21,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, true>();
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp
+++ test/std/utilities/ratio/ratio.comparison/ratio_greater_equal.pass.cpp
@@ -21,7 +21,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, true>();
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp
+++ test/std/utilities/ratio/ratio.comparison/ratio_less.pass.cpp
@@ -21,7 +21,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -93,4 +93,6 @@
     typedef std::ratio<641981, 1339063> R2;
     test<R1, R2, true>();
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp
+++ test/std/utilities/ratio/ratio.comparison/ratio_less_equal.pass.cpp
@@ -21,7 +21,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, false>();
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp
+++ test/std/utilities/ratio/ratio.comparison/ratio_not_equal.pass.cpp
@@ -21,7 +21,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::ratio<1, 1> R1;
@@ -63,4 +63,6 @@
     typedef std::ratio<1, -0x7FFFFFFFFFFFFFFFLL> R2;
     test<R1, R2, true>();
     }
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp
+++ test/std/utilities/ratio/ratio.ratio/ratio.pass.cpp
@@ -18,7 +18,7 @@
     static_assert((std::ratio<N, D>::den == eD), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<1, 1, 1, 1>();
     test<1, 10, 1, 10>();
@@ -40,4 +40,6 @@
     test<-0x7FFFFFFFFFFFFFFFLL, 127, -72624976668147841LL, 1>();
     test<0x7FFFFFFFFFFFFFFFLL, -127, -72624976668147841LL, 1>();
     test<-0x7FFFFFFFFFFFFFFFLL, -127, 72624976668147841LL, 1>();
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp
===================================================================
--- test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp
+++ test/std/utilities/ratio/ratio.ratio/ratio1.fail.cpp
@@ -11,7 +11,9 @@
 #include <ratio>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
     const std::intmax_t t1 = std::ratio<1, 0>::num;
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp
===================================================================
--- test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp
+++ test/std/utilities/ratio/ratio.ratio/ratio2.fail.cpp
@@ -12,7 +12,9 @@
 #include <ratio>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
     const std::intmax_t t1 = std::ratio<0x8000000000000000ULL, 1>::num;
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp
===================================================================
--- test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp
+++ test/std/utilities/ratio/ratio.ratio/ratio3.fail.cpp
@@ -12,7 +12,9 @@
 #include <ratio>
 #include <cstdint>
 
-int main()
+int main(int, char**)
 {
     const std::intmax_t t1 = std::ratio<1, 0x8000000000000000ULL>::num;
+
+  return 0;
 }
Index: test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp
+++ test/std/utilities/ratio/ratio.si/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/ratio/typedefs.pass.cpp
===================================================================
--- test/std/utilities/ratio/typedefs.pass.cpp
+++ test/std/utilities/ratio/typedefs.pass.cpp
@@ -10,7 +10,7 @@
 
 #include <ratio>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::atto::num == 1 && std::atto::den == 1000000000000000000ULL, "");
     static_assert(std::femto::num == 1 && std::femto::den == 1000000000000000ULL, "");
@@ -28,4 +28,6 @@
     static_assert(std::tera::num == 1000000000000ULL && std::tera::den == 1, "");
     static_assert(std::peta::num == 1000000000000000ULL && std::peta::den == 1, "");
     static_assert(std::exa::num == 1000000000000000000ULL && std::exa::den == 1, "");
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/pointer_type.pass.cpp
@@ -54,7 +54,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp
@@ -107,7 +107,7 @@
 }
 
 
-int main() {
+int main(int, char**) {
   {
     test_basic</*IsArray*/ false>();
     test_sfinae<false>();
@@ -116,4 +116,6 @@
     test_basic</*IsArray*/ true>();
     test_sfinae<true>();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp
@@ -405,7 +405,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     test_sfinae</*IsArray*/false>();
     test_noexcept<false>();
@@ -416,4 +416,6 @@
     test_noexcept<true>();
     test_deleter_value_category<true>();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp
@@ -114,7 +114,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_sfinae();
   // FIXME: add tests
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp
@@ -113,7 +113,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_sfinae();
   {
     std::unique_ptr<B> bptr(new B);
@@ -141,4 +141,6 @@
   }
   assert(A::count == 0);
   assert(B::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/null.pass.cpp
@@ -32,7 +32,9 @@
   assert(A::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/nullptr.pass.cpp
@@ -33,7 +33,9 @@
   assert(A::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp
@@ -61,7 +61,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     B* p = new B;
     std::auto_ptr<B> ap(p);
@@ -93,4 +93,6 @@
   }
 #endif
   test_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp
@@ -94,7 +94,7 @@
   doIncompleteTypeTest<IncompleteType[], Deleter<IncompleteType[]> >(0);
 })
 
-int main() {
+int main(int, char**) {
   {
     test_sfinae<int>();
     test_basic<int>();
@@ -103,4 +103,6 @@
     test_sfinae<int[]>();
     test_basic<int[]>();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp
@@ -159,7 +159,7 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   {
     test_basic</*IsArray*/ false>();
     test_sfinae<int>();
@@ -170,4 +170,6 @@
     test_sfinae<int[]>();
     test_noexcept<int[]>();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.pass.cpp
@@ -204,7 +204,7 @@
 }
 
 
-int main() {
+int main(int, char**) {
   {
     test_sfinae</*IsArray*/false>();
     test_noexcept<false>();
@@ -215,4 +215,6 @@
     test_noexcept<true>();
     test_deleter_value_category<true>();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.runtime.pass.cpp
@@ -77,6 +77,8 @@
 }
 
 
-int main() {
+int main(int, char**) {
   test_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
@@ -157,7 +157,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     test_sfinae();
     test_noexcept();
@@ -244,4 +244,6 @@
     }
     checkNoneAlive();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/null.pass.cpp
@@ -61,7 +61,7 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   {
     // test_pointer_ctor<int>();
     test_pointer_deleter_ctor<int>();
@@ -70,4 +70,6 @@
     test_pointer_ctor<int[]>();
     test_pointer_deleter_ctor<int[]>();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp
@@ -93,7 +93,7 @@
   checkNumIncompleteTypeAlive(0);
 })
 
-int main() {
+int main(int, char**) {
   {
     test_basic<int>();
     test_sfinae<int>();
@@ -102,4 +102,6 @@
     test_basic<int[]>();
     test_sfinae<int[]>();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer.pass.cpp
@@ -156,7 +156,7 @@
   checkNumIncompleteTypeAlive(0);
 })
 
-int main() {
+int main(int, char**) {
   {
     test_pointer</*IsArray*/ false>();
     test_derived();
@@ -167,4 +167,6 @@
     test_sfinae<int[]>();
     test_sfinae_runtime();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.fail.cpp
@@ -22,7 +22,9 @@
   void operator()(int* p) const { delete p; }
 };
 
-int main() {
+int main(int, char**) {
   // expected-error@+1 {{call to deleted constructor of 'std::unique_ptr<int, const Deleter &>}}
   std::unique_ptr<int, const Deleter&> s((int*)nullptr, Deleter());
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/pointer_deleter.pass.cpp
@@ -309,7 +309,7 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   {
     test_basic</*IsArray*/ false>();
     test_nullptr<false>();
@@ -324,4 +324,6 @@
     test_sfinae_runtime();
     test_noexcept<true>();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.dtor/null.pass.cpp
@@ -41,7 +41,9 @@
   assert(d.state() == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic<int>();
   test_basic<int[]>();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/release.pass.cpp
@@ -49,7 +49,9 @@
   assert(A::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.pass.cpp
@@ -102,7 +102,7 @@
   assert(A::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   {
     test_reset_pointer</*IsArray*/ false>();
     test_reset_nullptr<false>();
@@ -113,4 +113,6 @@
     test_reset_nullptr<true>();
     test_reset_no_arg<true>();
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp
@@ -17,7 +17,7 @@
 
 #include "unique_ptr_test_helper.h"
 
-int main() {
+int main(int, char**) {
   {
     std::unique_ptr<A[]> p;
     p.reset(static_cast<B*>(nullptr)); // expected-error {{no matching member function for call to 'reset'}}
@@ -26,4 +26,6 @@
     std::unique_ptr<int[]> p;
     p.reset(static_cast<const int*>(nullptr)); // expected-error {{no matching member function for call to 'reset'}}
   }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.single.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "unique_ptr_test_helper.h"
 
-int main() {
+int main(int, char**) {
   {
     std::unique_ptr<A> p(new A);
     assert(A::count == 1);
@@ -42,4 +42,6 @@
   }
   assert(A::count == 0);
   assert(B::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset_self.pass.cpp
@@ -21,4 +21,6 @@
   void reset() { ptr_.reset(); }
 };
 
-int main() { (new A)->reset(); }
+int main(int, char**) { (new A)->reset(); 
+  return 0;
+}
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/swap.pass.cpp
@@ -81,7 +81,9 @@
   assert(TT::count == 0);
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
@@ -15,9 +15,11 @@
 #include <memory>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<int[]> p(new int(3));
   const std::unique_ptr<int[]>& cp = p;
   TEST_IGNORE_NODISCARD (*p);  // expected-error {{indirection requires pointer operand ('std::unique_ptr<int []>' invalid)}}
   TEST_IGNORE_NODISCARD (*cp); // expected-error {{indirection requires pointer operand ('const std::unique_ptr<int []>' invalid)}}
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.single.pass.cpp
@@ -15,7 +15,9 @@
 #include <memory>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<int> p(new int(3));
   assert(*p == 3);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/explicit_bool.pass.cpp
@@ -59,7 +59,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
@@ -44,7 +44,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp
@@ -58,7 +58,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_basic</*IsArray*/ false>();
   test_basic<true>();
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.runtime.fail.cpp
@@ -19,7 +19,7 @@
   int member;
 };
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<V[]> p;
   std::unique_ptr<V[]> const& cp = p;
 
@@ -28,4 +28,6 @@
 
   cp->member; // expected-error {{member reference type 'const std::unique_ptr<V []>' is not a pointer}}
               // expected-error@-1 {{no member named 'member'}}
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_arrow.single.pass.cpp
@@ -21,7 +21,9 @@
   A() : i_(7) {}
 };
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<A> p(new A);
   assert(p->i_ == 7);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
@@ -33,7 +33,7 @@
 
 int A::next_ = 0;
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<A[]> p(new A[3]);
   assert(p[0] == 1);
   assert(p[1] == 2);
@@ -44,4 +44,6 @@
   assert(p[0] == 3);
   assert(p[1] == 2);
   assert(p[2] == 1);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.single.fail.cpp
@@ -15,9 +15,11 @@
 #include <memory>
 #include <cassert>
 
-int main() {
+int main(int, char**) {
   std::unique_ptr<int> p(new int[3]);
   std::unique_ptr<int> const& cp = p;
   p[0];  // expected-error {{type 'std::unique_ptr<int>' does not provide a subscript operator}}
   cp[1]; // expected-error {{type 'const std::unique_ptr<int>' does not provide a subscript operator}}
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp
@@ -21,7 +21,7 @@
     int val_;
     };
 
-int main()
+int main(int, char**)
 {
     {
     auto p1 = std::make_unique<int[]>(5);
@@ -40,4 +40,6 @@
     for ( int i = 0; i < 7; ++i )
         assert ( p3[i].get () == 3 );
     }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array1.fail.cpp
@@ -10,7 +10,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     auto up1 = std::make_unique<std::string[]>("error"); // doesn't compile - no bound
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array2.fail.cpp
@@ -10,7 +10,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     auto up2 = std::make_unique<int[]>(10, 20, 30, 40);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array3.fail.cpp
@@ -10,7 +10,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     auto up3 = std::make_unique<int[5]>();    // this is deleted
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.array4.fail.cpp
@@ -10,7 +10,9 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     auto up4 = std::make_unique<int[5]>(11, 22, 33, 44, 55); // deleted
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp
@@ -11,7 +11,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
     std::unique_ptr<int> p1 = std::make_unique<int>(1);
@@ -28,4 +28,6 @@
     p2 = std::make_unique<std::string> ( 6, 'z' );
     assert ( *p2 == "zzzzzz" );
     }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/convert_ctor.pass.cpp
@@ -34,7 +34,7 @@
 
 int B::count = 0;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<B> d2;
     std::default_delete<A> d1 = d2;
@@ -44,4 +44,6 @@
     d1(p);
     assert(A::count == 0);
     assert(B::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/default.pass.cpp
@@ -23,11 +23,13 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<A> d;
     A* p = new A;
     assert(A::count == 1);
     d(p);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/incomplete.fail.cpp
@@ -17,9 +17,11 @@
 
 struct A;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<A> d;
     A* p = 0;
     d(p);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt/void.fail.cpp
@@ -15,9 +15,11 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::default_delete<const void> d;
     const void* p = 0;
     d(p);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.fail.cpp
@@ -24,8 +24,10 @@
 {
 };
 
-int main()
+int main(int, char**)
 {
     std::default_delete<B[]> d2;
     std::default_delete<A[]> d1 = d2;
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/convert_ctor.pass.cpp
@@ -19,9 +19,11 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::default_delete<int[]> d1;
     std::default_delete<const int[]> d2 = d1;
     ((void)d2);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/default.pass.cpp
@@ -25,11 +25,13 @@
 
 int A::count = 0;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<A[]> d;
     A* p = new A[3];
     assert(A::count == 3);
     d(p);
     assert(A::count == 0);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.dflt1/incomplete.fail.cpp
@@ -17,9 +17,11 @@
 
 struct A;
 
-int main()
+int main(int, char**)
 {
     std::default_delete<A[]> d;
     A* p = 0;
     d(p);
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.dltr/unique.ptr.dltr.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.special/cmp_nullptr.pass.cpp
@@ -40,7 +40,7 @@
 
 void do_nothing(int*) {}
 
-int main()
+int main(int, char**)
 {
     const std::unique_ptr<int> p1(new int(1));
     assert(!(p1 == nullptr));
@@ -65,4 +65,6 @@
     assert(!(nullptr > p2));
     assert( (p2 >= nullptr));
     assert( (nullptr >= p2));
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.special/eq.pass.cpp
@@ -44,7 +44,7 @@
 
 int B::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const std::unique_ptr<A, Deleter<A> > p1(new A);
@@ -82,4 +82,6 @@
     assert(p1 == p2);
     assert(!(p1 != p2));
     }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.special/rel.pass.cpp
@@ -52,7 +52,7 @@
 
 int B::count = 0;
 
-int main()
+int main(int, char**)
 {
     {
     const std::unique_ptr<A, Deleter<A> > p1(new A);
@@ -96,4 +96,6 @@
     assert((p1 < p2) == !(p1 <= p2));
     assert((p1 < p2) == !(p1 >= p2));
     }
+
+  return 0;
 }
Index: test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
===================================================================
--- test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
+++ test/std/utilities/smartptr/unique.ptr/unique.ptr.special/swap.pass.cpp
@@ -44,7 +44,7 @@
 
 };
 
-int main()
+int main(int, char**)
 {
     {
     A* p1 = new A(1);
@@ -98,4 +98,6 @@
         std::swap(p, p2);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
+++ test/std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
@@ -38,10 +38,12 @@
     ((void)result); // Prevent unused warning
 }
 
-int main()
+int main(int, char**)
 {
     test<0>();
     test<10>();
     test<100>();
     test<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
+++ test/std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
   {
     test_hash_enabled_for_type<std::bitset<0> >();
@@ -25,4 +25,6 @@
     test_hash_enabled_for_type<std::bitset<1024> >();
     test_hash_enabled_for_type<std::bitset<100000> >();
   }
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
+++ test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
@@ -46,7 +46,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_char_pointer_ctor<0>();
     test_char_pointer_ctor<1>();
@@ -57,4 +57,6 @@
     test_char_pointer_ctor<64>();
     test_char_pointer_ctor<65>();
     test_char_pointer_ctor<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
+++ test/std/utilities/template.bitset/bitset.cons/default.pass.cpp
@@ -35,7 +35,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     test_default_ctor<0>();
     test_default_ctor<1>();
@@ -46,4 +46,6 @@
     test_default_ctor<64>();
     test_default_ctor<65>();
     test_default_ctor<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
+++ test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
@@ -74,7 +74,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_string_ctor<0>();
     test_string_ctor<1>();
@@ -85,4 +85,6 @@
     test_string_ctor<64>();
     test_string_ctor<65>();
     test_string_ctor<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
+++ test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
@@ -39,7 +39,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_val_ctor<0>();
     test_val_ctor<1>();
@@ -50,4 +50,6 @@
     test_val_ctor<64>();
     test_val_ctor<65>();
     test_val_ctor<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/all.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/all.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/all.pass.cpp
@@ -28,7 +28,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_all<0>();
     test_all<1>();
@@ -39,4 +39,6 @@
     test_all<64>();
     test_all<65>();
     test_all<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/any.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/any.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/any.pass.cpp
@@ -31,7 +31,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_any<0>();
     test_any<1>();
@@ -42,4 +42,6 @@
     test_any<64>();
     test_any<65>();
     test_any<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/count.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/count.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/count.pass.cpp
@@ -42,7 +42,7 @@
     assert(c1 == c2);
 }
 
-int main()
+int main(int, char**)
 {
     test_count<0>();
     test_count<1>();
@@ -53,4 +53,6 @@
     test_count<64>();
     test_count<65>();
     test_count<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
@@ -40,7 +40,7 @@
         assert(v2[i] == ~v1[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test_flip_all<0>();
     test_flip_all<1>();
@@ -51,4 +51,6 @@
     test_flip_all<64>();
     test_flip_all<65>();
     test_flip_all<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
@@ -58,7 +58,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_flip_one<0>(true);
     test_flip_one<1>(true);
@@ -69,4 +69,6 @@
     test_flip_one<64>(false);
     test_flip_one<65>(false);
     test_flip_one<1000>(false);
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/index.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/index.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/index.pass.cpp
@@ -60,7 +60,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_index_const<0>();
     test_index_const<1>();
@@ -71,4 +71,6 @@
     test_index_const<64>();
     test_index_const<65>();
     test_index_const<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp
@@ -42,7 +42,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_index_const<0>();
     test_index_const<1>();
@@ -53,4 +53,6 @@
     test_index_const<64>();
     test_index_const<65>();
     test_index_const<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
@@ -41,7 +41,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_left_shift<0>();
     test_left_shift<1>();
@@ -52,4 +52,6 @@
     test_left_shift<64>();
     test_left_shift<65>();
     test_left_shift<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
@@ -46,7 +46,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_left_shift<0>();
     test_left_shift<1>();
@@ -57,4 +57,6 @@
     test_left_shift<64>();
     test_left_shift<65>();
     test_left_shift<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/none.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/none.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/none.pass.cpp
@@ -31,7 +31,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_none<0>();
     test_none<1>();
@@ -42,4 +42,6 @@
     test_none<64>();
     test_none<65>();
     test_none<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/not_all.pass.cpp
@@ -39,7 +39,7 @@
         assert(v2[i] == ~v1[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test_not_all<0>();
     test_not_all<1>();
@@ -50,4 +50,6 @@
     test_not_all<64>();
     test_not_all<65>();
     test_not_all<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
@@ -41,7 +41,7 @@
         assert(v1[i] == (v3[i] && v2[i]));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_and_eq<0>();
     test_op_and_eq<1>();
@@ -52,4 +52,6 @@
     test_op_and_eq<64>();
     test_op_and_eq<65>();
     test_op_and_eq<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
@@ -48,7 +48,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_equality<0>();
     test_equality<1>();
@@ -59,4 +59,6 @@
     test_equality<64>();
     test_equality<65>();
     test_equality<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
@@ -41,7 +41,7 @@
         assert(v1[i] == (v3[i] || v2[i]));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_or_eq<0>();
     test_op_or_eq<1>();
@@ -52,4 +52,6 @@
     test_op_or_eq<64>();
     test_op_or_eq<65>();
     test_op_or_eq<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
@@ -41,7 +41,7 @@
         assert(v1[i] == (v3[i] != v2[i]));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_xor_eq<0>();
     test_op_xor_eq<1>();
@@ -52,4 +52,6 @@
     test_op_xor_eq<64>();
     test_op_xor_eq<65>();
     test_op_xor_eq<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
@@ -29,7 +29,7 @@
         assert(!v[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test_reset_all<0>();
     test_reset_all<1>();
@@ -40,4 +40,6 @@
     test_reset_all<64>();
     test_reset_all<65>();
     test_reset_all<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
@@ -43,7 +43,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_reset_one<0>(true);
     test_reset_one<1>(true);
@@ -54,4 +54,6 @@
     test_reset_one<64>(false);
     test_reset_one<65>(false);
     test_reset_one<1000>(false);
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
@@ -41,7 +41,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_right_shift<0>();
     test_right_shift<1>();
@@ -52,4 +52,6 @@
     test_right_shift<64>();
     test_right_shift<65>();
     test_right_shift<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
@@ -46,7 +46,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_right_shift<0>();
     test_right_shift<1>();
@@ -57,4 +57,6 @@
     test_right_shift<64>();
     test_right_shift<65>();
     test_right_shift<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/set_all.pass.cpp
@@ -28,7 +28,7 @@
         assert(v[i]);
 }
 
-int main()
+int main(int, char**)
 {
     test_set_all<0>();
     test_set_all<1>();
@@ -39,4 +39,6 @@
     test_set_all<64>();
     test_set_all<65>();
     test_set_all<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp
@@ -52,7 +52,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_set_one<0>(true);
     test_set_one<1>(true);
@@ -63,4 +63,6 @@
     test_set_one<64>(false);
     test_set_one<65>(false);
     test_set_one<1000>(false);
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/size.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/size.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/size.pass.cpp
@@ -18,7 +18,7 @@
     assert(v.size() == N);
 }
 
-int main()
+int main(int, char**)
 {
     test_size<0>();
     test_size<1>();
@@ -29,4 +29,6 @@
     test_size<64>();
     test_size<65>();
     test_size<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/test.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/test.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/test.pass.cpp
@@ -53,7 +53,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test_test<0>(true);
     test_test<1>(true);
@@ -64,4 +64,6 @@
     test_test<64>(false);
     test_test<65>(false);
     test_test<1000>(false);
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/to_string.pass.cpp
@@ -153,7 +153,7 @@
 }
 }
 
-int main()
+int main(int, char**)
 {
     test_to_string<0>();
     test_to_string<1>();
@@ -164,4 +164,6 @@
     test_to_string<64>();
     test_to_string<65>();
     test_to_string<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
@@ -44,7 +44,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
 //     test_to_ullong<0>();
     test_to_ullong<1>();
@@ -55,4 +55,6 @@
     test_to_ullong<64>();
     test_to_ullong<65>();
     test_to_ullong<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
+++ test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
@@ -46,7 +46,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_to_ulong<0>();
     test_to_ulong<1>();
@@ -57,4 +57,6 @@
     test_to_ulong<64>();
     test_to_ulong<65>();
     test_to_ulong<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
+++ test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
@@ -39,7 +39,7 @@
     assert((v1 & v2) == (v3 &= v2));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_and<0>();
     test_op_and<1>();
@@ -50,4 +50,6 @@
     test_op_and<64>();
     test_op_and<65>();
     test_op_and<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
+++ test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
@@ -39,7 +39,7 @@
     assert((v1 ^ v2) == (v3 ^= v2));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_not<0>();
     test_op_not<1>();
@@ -50,4 +50,6 @@
     test_op_not<64>();
     test_op_not<65>();
     test_op_not<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
+++ test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
@@ -39,7 +39,7 @@
     assert((v1 | v2) == (v3 |= v2));
 }
 
-int main()
+int main(int, char**)
 {
     test_op_or<0>();
     test_op_or<1>();
@@ -50,4 +50,6 @@
     test_op_or<64>();
     test_op_or<65>();
     test_op_or<1000>();
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
+++ test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
@@ -16,10 +16,12 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::istringstream in("01011010");
     std::bitset<8> b;
     in >> b;
     assert(b.to_ulong() == 0x5A);
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
+++ test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp
@@ -16,10 +16,12 @@
 #include <sstream>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::ostringstream os;
     std::bitset<8> b(0x5A);
     os << b;
     assert(os.str() == "01011010");
+
+  return 0;
 }
Index: test/std/utilities/template.bitset/includes.pass.cpp
===================================================================
--- test/std/utilities/template.bitset/includes.pass.cpp
+++ test/std/utilities/template.bitset/includes.pass.cpp
@@ -12,7 +12,7 @@
 
 template <class> void test_typedef() {}
 
-int main()
+int main(int, char**)
 {
   { // test for <string>
     std::string s; ((void)s);
@@ -24,4 +24,6 @@
     test_typedef<std::ostream>();
     test_typedef<std::iostream>();
   }
+
+  return 0;
 }
Index: test/std/utilities/time/date.time/ctime.pass.cpp
===================================================================
--- test/std/utilities/time/date.time/ctime.pass.cpp
+++ test/std/utilities/time/date.time/ctime.pass.cpp
@@ -29,7 +29,7 @@
 #pragma GCC diagnostic ignored "-Wformat-zero-length"
 #endif
 
-int main()
+int main(int, char**)
 {
     std::clock_t c = 0;
     std::size_t s = 0;
@@ -60,4 +60,6 @@
     static_assert((std::is_same<decltype(std::localtime(&t)), std::tm*>::value), "");
 #endif
     static_assert((std::is_same<decltype(std::strftime(str,s,"",&tm)), std::size_t>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/days.pass.cpp
===================================================================
--- test/std/utilities/time/days.pass.cpp
+++ test/std/utilities/time/days.pass.cpp
@@ -15,7 +15,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::days D;
     typedef D::rep Rep;
@@ -24,4 +24,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 25, "");
     static_assert(std::is_same_v<Period, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/hours.pass.cpp
===================================================================
--- test/std/utilities/time/hours.pass.cpp
+++ test/std/utilities/time/hours.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::hours D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 22, "");
     static_assert((std::is_same<Period, std::ratio<3600> >::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/microseconds.pass.cpp
===================================================================
--- test/std/utilities/time/microseconds.pass.cpp
+++ test/std/utilities/time/microseconds.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::microseconds D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 54, "");
     static_assert((std::is_same<Period, std::micro>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/milliseconds.pass.cpp
===================================================================
--- test/std/utilities/time/milliseconds.pass.cpp
+++ test/std/utilities/time/milliseconds.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::milliseconds D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 44, "");
     static_assert((std::is_same<Period, std::milli>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/minutes.pass.cpp
===================================================================
--- test/std/utilities/time/minutes.pass.cpp
+++ test/std/utilities/time/minutes.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::minutes D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 28, "");
     static_assert((std::is_same<Period, std::ratio<60> >::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/months.pass.cpp
===================================================================
--- test/std/utilities/time/months.pass.cpp
+++ test/std/utilities/time/months.pass.cpp
@@ -16,7 +16,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::months D;
     typedef D::rep Rep;
@@ -25,4 +25,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 20, "");
     static_assert(std::is_same_v<Period, std::ratio_divide<std::chrono::years::period, std::ratio<12>>>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/nanoseconds.pass.cpp
===================================================================
--- test/std/utilities/time/nanoseconds.pass.cpp
+++ test/std/utilities/time/nanoseconds.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::nanoseconds D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 63, "");
     static_assert((std::is_same<Period, std::nano>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/seconds.pass.cpp
===================================================================
--- test/std/utilities/time/seconds.pass.cpp
+++ test/std/utilities/time/seconds.pass.cpp
@@ -14,7 +14,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::seconds D;
     typedef D::rep Rep;
@@ -23,4 +23,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 34, "");
     static_assert((std::is_same<Period, std::ratio<1> >::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/nothing_to_do.pass.cpp
+++ test/std/utilities/time/time.cal/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
 
@@ -42,4 +42,6 @@
         day day(i);
         assert(static_cast<unsigned>(day) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp
@@ -30,7 +30,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
     ASSERT_NOEXCEPT(--(std::declval<day&>())  );
@@ -48,4 +48,6 @@
         assert(static_cast<unsigned>(day--) == i - 1);
         assert(static_cast<unsigned>(day)   == i - 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp
@@ -30,7 +30,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
     ASSERT_NOEXCEPT(++(std::declval<day&>())  );
@@ -48,4 +48,6 @@
         assert(static_cast<unsigned>(day++) == i + 1);
         assert(static_cast<unsigned>(day)   == i + 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
     ASSERT_NOEXCEPT(                std::declval<const day>().ok());
@@ -33,4 +33,6 @@
         assert(day{i}.ok());
     for (unsigned i = 32; i <= 255; ++i)
         assert(!day{i}.ok());
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day  = std::chrono::day;
     using days = std::chrono::days;
@@ -53,4 +53,6 @@
         assert(static_cast<unsigned>(day -= days{12}) == i + 10);
         assert(static_cast<unsigned>(day)             == i + 10);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
 
@@ -40,4 +40,6 @@
     for (unsigned i = 1; i < 10; ++i)
         for (unsigned j = 1; j < 10; ++j)
             assert(testComparisons6Values<day>(i, j));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
     day d1 = 4d; // expected-error-re {{no matching literal operator for call to 'operator""d' {{.*}}}}
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     using namespace std::chrono;
@@ -43,4 +43,6 @@
     assert (d1 == std::chrono::day(4));
     }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp
@@ -33,7 +33,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day  = std::chrono::day;
     using days = std::chrono::days;
@@ -54,4 +54,6 @@
         assert(static_cast<unsigned>(d1) == 12 - i);
         assert(off.count() == static_cast<int>(12 - i)); // days is signed
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp
@@ -33,7 +33,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using day  = std::chrono::day;
     using days = std::chrono::days;
@@ -55,4 +55,6 @@
         assert(static_cast<unsigned>(d1) == i + 12);
         assert(static_cast<unsigned>(d2) == i + 12);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp
@@ -48,8 +48,10 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using day = std::chrono::day;
    std::cout << day{1};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.day/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day = std::chrono::day;
 
     static_assert(std::is_trivially_copyable_v<day>, "");
     static_assert(std::is_standard_layout_v<day>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.last/types.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using last_spec = std::chrono::last_spec;
 
@@ -29,4 +29,6 @@
 
     static_assert(std::is_trivially_copyable_v<last_spec>, "");
     static_assert(std::is_standard_layout_v<last_spec>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month     = std::chrono::month;
@@ -43,4 +43,6 @@
     static_assert( md1.month() == std::chrono::January, "");
     static_assert( md1.day()   == day{4},               "");
     static_assert( md1.ok(),                            "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month_day = std::chrono::month_day;
@@ -34,4 +34,6 @@
         month_day md(std::chrono::March, day{i});
         assert( static_cast<unsigned>(md.day()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month     = std::chrono::month;
@@ -35,4 +35,6 @@
         month_day md(month{i}, day{1});
         assert( static_cast<unsigned>(md.month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month     = std::chrono::month;
@@ -51,4 +51,6 @@
 //  If the month is not ok, all the days are bad
     for (unsigned i = 1; i <= 35; ++i)
         assert(!(month_day{month{13}, day{i}}.ok()));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using day       = std::chrono::day;
     using month     = std::chrono::month;
@@ -66,4 +66,6 @@
                 month_day{month{2}, day{j}},
                 i == j, i < j )));
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp
@@ -31,10 +31,12 @@
 #include <iostream>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_day = std::chrono::month_day;
     using month     = std::chrono::month;
     using day       = std::chrono::day;
     std::cout << month_day{month{1}, day{1}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.md/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_day = std::chrono::month_day;
 
     static_assert(std::is_trivially_copyable_v<month_day>, "");
     static_assert(std::is_standard_layout_v<month_day>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month          = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -39,4 +39,6 @@
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
             assert((testComparisons6Values<month_day_last>(month{i}, month{j})));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month     = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -37,4 +37,6 @@
     constexpr month_day_last md1{std::chrono::January};
     static_assert( md1.month() == std::chrono::January, "");
     static_assert( md1.ok(),                            "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month     = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -34,4 +34,6 @@
         month_day_last mdl(month{i});
         assert( static_cast<unsigned>(mdl.month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month          = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -42,4 +42,6 @@
         month_day_last mdl{month{i}};
         assert(!mdl.ok());
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp
@@ -25,9 +25,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_day_last = std::chrono::month_day_last;
     using month          = std::chrono::month;
     std::cout << month_day_last{month{1}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_day_last = std::chrono::month_day_last;
 
     static_assert(std::is_trivially_copyable_v<month_day_last>, "");
     static_assert(std::is_standard_layout_v<month_day_last>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
@@ -42,4 +42,6 @@
         month m(i);
         assert(static_cast<unsigned>(m) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp
@@ -30,7 +30,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
@@ -49,4 +49,6 @@
         assert(static_cast<unsigned>(month--) == i - 1);
         assert(static_cast<unsigned>(month)   == i - 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp
@@ -30,7 +30,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
     ASSERT_NOEXCEPT(++(std::declval<month&>())  );
@@ -48,4 +48,6 @@
         assert(static_cast<unsigned>(month++) == i + 1);
         assert(static_cast<unsigned>(month)   == i + 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
@@ -34,4 +34,6 @@
         assert(month{i}.ok());
     for (unsigned i = 13; i <= 255; ++i)
         assert(!month{i}.ok());
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month  = std::chrono::month;
     using months = std::chrono::months;
@@ -63,4 +63,6 @@
         assert(static_cast<unsigned>(month -= months{ 9}) == static_cast<unsigned>(exp));
         assert(static_cast<unsigned>(month)               == static_cast<unsigned>(exp));
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_comparisons.h"
 
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
@@ -43,4 +43,6 @@
     for (unsigned i = 1; i < 10; ++i)
         for (unsigned j = 10; j < 10; ++j)
             assert(testComparisons6Values<month>(i, j));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 
     ASSERT_SAME_TYPE(const std::chrono::month, decltype(std::chrono::January));
@@ -83,4 +83,6 @@
     assert(static_cast<unsigned>(std::chrono::October)   == 10);
     assert(static_cast<unsigned>(std::chrono::November)  == 11);
     assert(static_cast<unsigned>(std::chrono::December)  == 12);
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp
@@ -44,7 +44,7 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
     using month  = std::chrono::month;
     using months = std::chrono::months;
@@ -68,4 +68,6 @@
         assert(static_cast<unsigned>(m1) == static_cast<unsigned>(exp));
 //          assert(off.count()               == static_cast<unsigned>(exp));
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp
@@ -43,7 +43,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month  = std::chrono::month;
     using months = std::chrono::months;
@@ -68,4 +68,6 @@
         assert(static_cast<unsigned>(m1) == exp);
         assert(static_cast<unsigned>(m2) == exp);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp
@@ -45,8 +45,10 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using month = std::chrono::month;
    std::cout << month{1};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.month/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month = std::chrono::month;
 
     static_assert(std::is_trivially_copyable_v<month>, "");
     static_assert(std::is_standard_layout_v<month>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -42,4 +42,6 @@
     static_assert( md1.month() == std::chrono::January,                              "");
     static_assert( md1.weekday_indexed() == weekday_indexed{std::chrono::Friday, 4}, "");
     static_assert( md1.ok(),                                                         "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -38,4 +38,6 @@
         month_weekday md(month{i}, weekday_indexed{Sunday, 1});
         assert( static_cast<unsigned>(md.month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -47,4 +47,6 @@
 //  If the month is not ok, all the weekday_indexed are bad
     for (unsigned i = 1; i <= 10; ++i)
         assert(!(month_weekday{month{13}, weekday_indexed{Sunday, i}}.ok()));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -39,4 +39,6 @@
         assert( static_cast<unsigned>(md.weekday_indexed().weekday() == Sunday));
         assert( static_cast<unsigned>(md.weekday_indexed().index() == i));
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -82,4 +82,6 @@
                 month_weekday{month{2}, weekday_indexed{weekday{i}, 2}},
                 month_weekday{month{2}, weekday_indexed{weekday{j}, 2}},
                 i == j)));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -32,4 +32,6 @@
     using weekday         = std::chrono::weekday;
 
     std::cout << month_weekday{month{1}, weekday_indexed{weekday{3}, 3}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday = std::chrono::month_weekday;
 
     static_assert(std::is_trivially_copyable_v<month_weekday>, "");
     static_assert(std::is_standard_layout_v<month_weekday>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
@@ -56,4 +56,6 @@
     static_assert( mwdl3.month() == January,                         "");
     static_assert( mwdl3.weekday_last() == weekday_last{weekday{4}}, "");
     static_assert( mwdl3.ok(),                                       "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
@@ -38,4 +38,6 @@
         month_weekday_last mdl(month{i}, weekday_last{Tuesday});
         assert( static_cast<unsigned>(mdl.month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
@@ -48,4 +48,6 @@
         month_weekday_last mwdl{January, weekday_last{weekday{i}}};
         assert( mwdl.ok() == weekday_last{weekday{i}}.ok());
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
@@ -40,4 +40,6 @@
         month_weekday_last mdl(January, weekday_last{weekday{i}});
         assert( static_cast<unsigned>(mdl.weekday_last().weekday()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month              = std::chrono::month;
     using weekday_last       = std::chrono::weekday_last;
@@ -69,4 +69,6 @@
             month_weekday_last{month{1}, weekday_last{weekday{1}}},
             month_weekday_last{month{2}, weekday_last{weekday{2}}},
         false)));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday_last = std::chrono::month_weekday_last;
     using month              = std::chrono::month;
@@ -33,4 +33,6 @@
     using weekday_last       = std::chrono::weekday_last;
 
     std::cout << month_weekday_last{month{1}, weekday_last{weekday{3}}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp
@@ -17,10 +17,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday_last = std::chrono::month_weekday_last;
 
     static_assert(std::is_trivially_copyable_v<month_weekday_last>, "");
     static_assert(std::is_standard_layout_v<month_weekday_last>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp
@@ -38,7 +38,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month_day = std::chrono::month_day;
     using month     = std::chrono::month;
@@ -104,4 +104,6 @@
                 assert(md1 == md2);
             }
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp
@@ -46,7 +46,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month          = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
@@ -103,4 +103,6 @@
         }
     }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp
@@ -44,7 +44,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
@@ -111,4 +111,6 @@
                     assert(mwd1 == mwd2);
                 }
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp
@@ -36,7 +36,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month_weekday      = std::chrono::month_weekday;
     using month              = std::chrono::month;
@@ -103,4 +103,6 @@
                 assert(mwd1 == mwd2);
             }
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month      = std::chrono::month;
     using year       = std::chrono::year;
@@ -64,4 +64,6 @@
                 assert(static_cast<unsigned>(ym.month()) == j);
             }
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp
@@ -42,7 +42,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -187,4 +187,6 @@
                 }
     }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp
@@ -38,7 +38,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using month               = std::chrono::month;
     using year_month          = std::chrono::year_month;
@@ -121,4 +121,6 @@
                 assert(ymdl1 == ymdl2);
             }
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp
@@ -37,7 +37,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using year_month         = std::chrono::year_month;
@@ -141,4 +141,6 @@
                         assert(ymd1 == ymd2);
                     }
      }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp
@@ -39,7 +39,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year_month         = std::chrono::year_month;
     using year               = std::chrono::year;
@@ -149,4 +149,6 @@
                     assert(ymwdl1 == ymwdl2);
                 }
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday  = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -57,4 +57,6 @@
         weekday_indexed wdi(std::chrono::Tuesday, i);
         assert(!wdi.ok());
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -34,4 +34,6 @@
         weekday_indexed wdi(weekday{2}, i);
         assert( static_cast<unsigned>(wdi.index()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -45,4 +45,6 @@
 
 //  Not a valid weekday
     assert(!(weekday_indexed(weekday{9U}, 1).ok()));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -35,4 +35,6 @@
         weekday_indexed wdi(weekday{i}, 2);
         assert( static_cast<unsigned>(wdi.weekday()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
@@ -44,4 +44,6 @@
     static_assert( (weekday_indexed{weekday{1}, 2} != weekday_indexed{weekday{1}, 1}), "");
     static_assert(!(weekday_indexed{weekday{1}, 2} == weekday_indexed{weekday{2}, 2}),  "");
     static_assert( (weekday_indexed{weekday{1}, 2} != weekday_indexed{weekday{2}, 2}),  "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp
@@ -26,10 +26,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday_indexed = std::chrono::weekday_indexed;
     using weekday         = std::chrono::weekday;
 
     std::cout << weekday_indexed{weekday{3}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday_indexed = std::chrono::weekday_indexed;
 
     static_assert(std::is_trivially_copyable_v<weekday_indexed>, "");
     static_assert(std::is_standard_layout_v<weekday_indexed>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday      = std::chrono::weekday;
     using weekday_last = std::chrono::weekday_last;
@@ -43,4 +43,6 @@
         weekday_last wdl{weekday{i}};
         assert(wdl.weekday() == weekday{i});
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday      = std::chrono::weekday;
     using weekday_last = std::chrono::weekday_last;
@@ -33,4 +33,6 @@
 
     for (unsigned i = 0; i <= 255; ++i)
         assert(weekday_last{weekday{i}}.ok() == weekday{i}.ok());
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday      = std::chrono::weekday;
     using weekday_last = std::chrono::weekday_last;
@@ -29,4 +29,6 @@
 
     for (unsigned i = 0; i <= 255; ++i)
         assert(weekday_last{weekday{i}}.weekday() == weekday{i});
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using weekday      = std::chrono::weekday;
     using weekday_last = std::chrono::weekday_last;
@@ -39,4 +39,6 @@
     for (unsigned i = 0; i < 6; ++i)
         for (unsigned j = 0; j < 6; ++j)
             assert(testComparisons2Values<weekday_last>(weekday{i}, weekday{j}));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp
@@ -24,10 +24,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using weekday_last = std::chrono::weekday_last;
    using weekday      = std::chrono::weekday;
 
    std::cout << weekday_last{weekday{3}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday_last = std::chrono::weekday_last;
 
     static_assert(std::is_trivially_copyable_v<weekday_last>, "");
     static_assert(std::is_standard_layout_v<weekday_last>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using local_days = std::chrono::local_days;
     using days       = std::chrono::days;
@@ -69,4 +69,6 @@
     assert( wd.ok());
     assert(static_cast<unsigned>(wd) == 3);
     }
+
+    return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
 
@@ -47,4 +47,6 @@
     }
 
 // TODO - sys_days and local_days ctor tests
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using sys_days  = std::chrono::sys_days;
     using days      = std::chrono::days;
@@ -69,4 +69,6 @@
     assert( wd.ok());
     assert(static_cast<unsigned>(wd) == 3);
     }
+
+    return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp
@@ -31,7 +31,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
     ASSERT_NOEXCEPT(--(std::declval<weekday&>())  );
@@ -49,4 +49,6 @@
         assert((static_cast<unsigned>(wd--) == euclidian_subtraction<unsigned, 0, 6>(i, 1)));
         assert((static_cast<unsigned>(wd)   == euclidian_subtraction<unsigned, 0, 6>(i, 2)));
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp
@@ -31,7 +31,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
     ASSERT_NOEXCEPT(++(std::declval<weekday&>())  );
@@ -49,4 +49,6 @@
         assert((static_cast<unsigned>(wd++) == euclidian_addition<unsigned, 0, 6>(i, 1)));
         assert((static_cast<unsigned>(wd)   == euclidian_addition<unsigned, 0, 6>(i, 2)));
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
 
@@ -34,4 +34,6 @@
         assert(weekday{i}.ok());
     for (unsigned i = 7; i <= 255; ++i)
         assert(!weekday{i}.ok());
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "../../euclidian.h"
 
-int main()
+int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_last    = std::chrono::weekday_last;
@@ -55,4 +55,6 @@
         assert(wdi.index() == j);
         assert(wdi.ok());
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp
@@ -33,7 +33,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
     using days    = std::chrono::days;
@@ -59,4 +59,6 @@
         assert((static_cast<unsigned>(wd -= days{4}) == euclidian_subtraction<unsigned, 0, 6>(i, 4)));
         assert((static_cast<unsigned>(wd)            == euclidian_subtraction<unsigned, 0, 6>(i, 4)));
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
 
@@ -38,4 +38,6 @@
     for (unsigned i = 0; i < 6; ++i)
         for (unsigned j = 0; j < 6; ++j)
             assert(testComparisons2Values<weekday>(i, j));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
 
     ASSERT_SAME_TYPE(const std::chrono::weekday, decltype(std::chrono::Sunday));
@@ -58,4 +58,6 @@
     assert(static_cast<unsigned>(std::chrono::Thursday)  ==  4);
     assert(static_cast<unsigned>(std::chrono::Friday)    ==  5);
     assert(static_cast<unsigned>(std::chrono::Saturday)  ==  6);
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp
@@ -44,7 +44,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday  = std::chrono::weekday;
     using days     = std::chrono::days;
@@ -72,4 +72,6 @@
             assert(weekday{i} + d == weekday{j});
         }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp
@@ -44,7 +44,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
     using days    = std::chrono::days;
@@ -66,4 +66,6 @@
             assert((static_cast<unsigned>(wd1) == euclidian_addition<unsigned, 0, 6>(i, j)));
             assert((static_cast<unsigned>(wd2) == euclidian_addition<unsigned, 0, 6>(i, j)));
         }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp
@@ -47,9 +47,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using weekday = std::chrono::weekday;
 
    std::cout << weekday{3};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using weekday = std::chrono::weekday;
 
     static_assert(std::is_trivially_copyable_v<weekday>, "");
     static_assert(std::is_standard_layout_v<weekday>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
@@ -42,4 +42,6 @@
         year year(i);
         assert(static_cast<int>(year) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp
@@ -30,7 +30,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
     ASSERT_NOEXCEPT(--(std::declval<year&>())  );
@@ -48,4 +48,6 @@
         assert(static_cast<int>(year--) == i - 1);
         assert(static_cast<int>(year)   == i - 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp
@@ -30,7 +30,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
     ASSERT_NOEXCEPT(++(std::declval<year&>())  );
@@ -48,4 +48,6 @@
         assert(static_cast<int>(year++) == i + 1);
         assert(static_cast<int>(year)   == i + 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
@@ -49,4 +49,6 @@
     assert(!year{ 2003}.is_leap());
     assert( year{ 2004}.is_leap());
     assert(!year{ 2100}.is_leap());
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
@@ -49,4 +49,6 @@
     assert(year{ 20001}.ok());
 
     static_assert(!year{-32768}.ok(), "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp
@@ -28,7 +28,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year  = std::chrono::year;
 
@@ -46,4 +46,6 @@
         assert(static_cast<int>(+year) ==  i);
         assert(static_cast<int>(-year) == -i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year  = std::chrono::year;
     using years = std::chrono::years;
@@ -53,4 +53,6 @@
         assert(static_cast<int>(year -= years{ 9}) == i +  1);
         assert(static_cast<int>(year)              == i +  1);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_comparisons.h"
 
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
@@ -43,4 +43,6 @@
     for (int i = 1; i < 10; ++i)
         for (int j = 1; j < 10; ++j)
             assert(testComparisons6Values<year>(i, j));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.fail.cpp
@@ -20,8 +20,10 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using std::chrono::year;
     year d1 = 1234y; // expected-error-re {{no matching literal operator for call to 'operator""y' {{.*}}}}
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     using namespace std::chrono;
@@ -40,4 +40,6 @@
     std::chrono::year y1 = 2020y;
     assert (y1 == std::chrono::year(2020));
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp
@@ -37,7 +37,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year  = std::chrono::year;
     using years = std::chrono::years;
@@ -58,4 +58,6 @@
         assert(static_cast<int>(y1) == 1223 - i);
         assert(ys1.count()          == 1223 - i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp
@@ -33,7 +33,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year  = std::chrono::year;
     using years = std::chrono::years;
@@ -55,4 +55,6 @@
         assert(static_cast<int>(y1) == i + 1223);
         assert(static_cast<int>(y2) == i + 1223);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp
@@ -46,9 +46,11 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
    using year = std::chrono::year;
 
    std::cout << year{2018};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.year/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year = std::chrono::year;
 
     static_assert(std::is_trivially_copyable_v<year>, "");
     static_assert(std::is_standard_layout_v<year>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using month      = std::chrono::month;
@@ -48,4 +48,6 @@
     static_assert( ym2.year()  == year{2018}, "");
     static_assert( ym2.month() == month{},    "");
     static_assert(!ym2.ok(),                  "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using month      = std::chrono::month;
@@ -35,4 +35,6 @@
         year_month ym(year{1234}, month{i});
         assert( static_cast<unsigned>(ym.month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using month      = std::chrono::month;
     using year       = std::chrono::year;
@@ -46,4 +46,6 @@
         year_month ym{year{i}, January};
         assert( ym.ok() == year{i}.ok());
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month      = std::chrono::month;
     using months     = std::chrono::months;
@@ -60,4 +60,6 @@
         assert(static_cast<unsigned>((ym             ).month()) == i + 1);
         assert(ym.year() == y);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using month      = std::chrono::month;
     using year       = std::chrono::year;
@@ -61,4 +61,6 @@
         assert(static_cast<int>((ym            ).year()) == i + 1);
         assert(ym.month() == m);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using month      = std::chrono::month;
@@ -35,4 +35,6 @@
         year_month ym(year{i}, month{});
         assert( static_cast<int>(ym.year()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using month      = std::chrono::month;
@@ -65,4 +65,6 @@
             year_month{year{i}, std::chrono::January},
             year_month{year{j}, std::chrono::January},
             i == j, i < j )));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp
@@ -29,7 +29,7 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using years      = std::chrono::years;
@@ -86,4 +86,6 @@
 //  TODO: different year
 
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp
@@ -51,7 +51,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     using year       = std::chrono::year;
     using years      = std::chrono::years;
@@ -102,4 +102,6 @@
         assert(ym1 == ym2);
     }
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp
@@ -46,11 +46,13 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month = std::chrono::year_month;
     using year       = std::chrono::year;
     using month      = std::chrono::month;
 
     std::cout << year_month{year{2018}, month{3}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ym/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month = std::chrono::year_month;
 
     static_assert(std::is_trivially_copyable_v<year_month>, "");
     static_assert(std::is_standard_layout_v<year_month>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using day            = std::chrono::day;
@@ -81,4 +81,6 @@
     assert( ymd.month() == std::chrono::November);
     assert( ymd.day()   == day{29});
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -52,4 +52,6 @@
     static_assert( ym1.day()   == day{12},    "");
     static_assert( ym1.ok(),                  "");
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using day            = std::chrono::day;
@@ -80,4 +80,6 @@
     assert( ymd.month() == std::chrono::November);
     assert( ymd.day()   == day{29});
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -76,4 +76,6 @@
     assert( ymd.day()   == day{28});
     assert( ymd.ok());
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -36,4 +36,6 @@
         year_month_day ymd(year{1234}, month{2}, day{i});
         assert( static_cast<unsigned>(ymd.day()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -36,4 +36,6 @@
         year_month_day ymd(year{1234}, month{i}, day{12});
         assert( static_cast<unsigned>(ymd.month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -92,4 +92,6 @@
         year_month_day ym{year{i}, January, day{12}};
         assert( ym.ok() == year{i}.ok());
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
@@ -44,7 +44,7 @@
     static_assert(year_month_day{local_days{year{2017}/January/32}} == year{2017}/February/1);  
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -90,4 +90,5 @@
     assert( year_month_day{sd} == ymd); // and back
     }
 
+    return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
@@ -44,7 +44,7 @@
     static_assert(year_month_day{sys_days{year{2017}/January/32}} == year{2017}/February/1);  
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -90,4 +90,5 @@
     assert( year_month_day{sd} == ymd); // and back
     }
 
+    return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -66,4 +66,6 @@
         assert(ym.year() == y);
         assert(ym.day()  == d);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -66,4 +66,6 @@
         assert(ym.month() == m);
         assert(ym.day()   == d);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -36,4 +36,6 @@
         year_month_day ym(year{i}, month{}, day{});
         assert( static_cast<int>(ym.year()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using day        = std::chrono::day;
     using year       = std::chrono::year;
@@ -114,4 +114,6 @@
             year_month_day{year{i}, January, day{12}},
             year_month_day{year{j}, January, day{12}},
             i == j, i < j )));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp
@@ -33,7 +33,7 @@
         ;
 }
 
-int main()
+int main(int, char**)
 {
     using year           = std::chrono::year;
     using month          = std::chrono::month;
@@ -56,4 +56,6 @@
         assert(ym1.month() == January);
         assert(ym1.day() == day{10});
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp
@@ -51,7 +51,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     using day        = std::chrono::day;
     using year       = std::chrono::year;
@@ -108,4 +108,6 @@
     }
     }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp
@@ -46,7 +46,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_day = std::chrono::year_month_day;
     using year           = std::chrono::year;
@@ -54,4 +54,6 @@
     using day            = std::chrono::day;
 
     std::cout << year_month_day{year{2018}, month{3}, day{12}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_day = std::chrono::year_month_day;
 
     static_assert(std::is_trivially_copyable_v<year_month_day>, "");
     static_assert(std::is_standard_layout_v<year_month_day>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -49,4 +49,6 @@
     static_assert( ymdl1.month()          == January,                 "");
     static_assert( ymdl1.month_day_last() == month_day_last{January}, "");
     static_assert( ymdl1.ok(),                                        "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -47,4 +47,6 @@
     assert((year_month_day_last{year{2019}, month_day_last{month{ 2}}}.day() == day{28}));
     assert((year_month_day_last{year{2020}, month_day_last{month{ 2}}}.day() == day{29}));
     assert((year_month_day_last{year{2021}, month_day_last{month{ 2}}}.day() == day{28}));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -34,4 +34,6 @@
         year_month_day_last ymd(year{1234}, month_day_last{month{i}});
         assert( static_cast<unsigned>(ymd.month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -34,4 +34,6 @@
         year_month_day_last ymdl(year{1234}, month_day_last{month{i}});
         assert( static_cast<unsigned>(ymdl.month_day_last().month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -48,4 +48,6 @@
         year_month_day_last ym{year{i}, month_day_last{January}};
         assert( ym.ok() == year{i}.ok());
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month_day_last      = std::chrono::month_day_last;
@@ -57,4 +57,6 @@
 
     assert(sd.time_since_epoch() == days{-(10957+33)});
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month_day_last      = std::chrono::month_day_last;
@@ -57,4 +57,6 @@
 
     assert(sd.time_since_epoch() == days{-(10957+33)});
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -62,4 +62,6 @@
         assert(static_cast<unsigned>((ym             ).month()) == i + 1);
         assert(ym.year() == y);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -61,4 +61,6 @@
         assert(static_cast<int>((ymdl            ).year()) == i + 1);
         assert(ymdl.month_day_last() == mdl);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -34,4 +34,6 @@
         year_month_day_last ym(year{i}, month_day_last{month{}});
         assert( static_cast<int>(ym.year()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp
@@ -26,7 +26,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -83,4 +83,6 @@
             year_month_day_last{year{i}, month_day_last{January}},
             year_month_day_last{year{j}, month_day_last{January}},
             i == j, i < j )));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp
@@ -47,7 +47,7 @@
         ;
 }
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -87,4 +87,6 @@
     }
     }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp
@@ -63,7 +63,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
@@ -118,4 +118,6 @@
     }
     }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_day_last = std::chrono::year_month_day_last;
     using year                = std::chrono::year;
@@ -33,4 +33,6 @@
     using month_day_last      = std::chrono::month_day_last;
 
     std::cout << year_month_day_last{year{2018}, month_day_last{month{3}}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using days               = std::chrono::days;
@@ -91,4 +91,6 @@
     assert((ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 5}));
     assert( ymwd                   == year_month_weekday{local_days{ymwd}}); // round trip
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp
@@ -30,7 +30,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -60,4 +60,6 @@
     static_assert( ym1.weekday_indexed() == weekday_indexed{Tuesday, 1}, "");
     static_assert( ym1.ok(),                                             "");
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using days               = std::chrono::days;
@@ -90,4 +90,6 @@
     assert((ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 5}));
     assert( ymwd                   == year_month_weekday{sys_days{ymwd}}); // round trip
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -37,4 +37,6 @@
         year_month_weekday ymwd0(year{1234}, month{2}, weekday_indexed{weekday{2}, i});
         assert(ymwd0.index() == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -36,4 +36,6 @@
         year_month_weekday ymd(year{1234}, month{i}, weekday_indexed{});
         assert( static_cast<unsigned>(ymd.month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -71,4 +71,6 @@
         year_month_weekday ym{year{i}, January, weekday_indexed{Tuesday, 1}};
         assert((ym.ok() == year{i}.ok()));
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -70,4 +70,5 @@
     assert( year_month_weekday{sd} == ymwd); // and back
     }
 
+    return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -70,4 +70,5 @@
     assert( year_month_weekday{sd} == ymwd); // and back
     }
 
+    return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -76,4 +76,6 @@
         assert(ymwd.weekday()  == Tuesday);
         assert(ymwd.index()    == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -76,4 +76,6 @@
         assert(ymwd.weekday()  == Tuesday);
         assert(ymwd.index()    == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -37,4 +37,6 @@
         year_month_weekday ymwd0(year{1234}, month{2}, weekday_indexed{weekday{i}, 1});
         assert(static_cast<unsigned>(ymwd0.weekday()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -41,4 +41,6 @@
         assert( static_cast<unsigned>(ymwd1.weekday_indexed().weekday()) == 2);
         assert( static_cast<unsigned>(ymwd1.weekday_indexed().index()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -36,4 +36,6 @@
         year_month_weekday ym(year{i}, month{1}, weekday_indexed{});
         assert( static_cast<int>(ym.year()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -109,4 +109,6 @@
             year_month_weekday{year{i}, January, weekday_indexed{Tuesday, 1}},
             year_month_weekday{year{j}, January, weekday_indexed{Tuesday, 1}},
             i == j)));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp
@@ -50,7 +50,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -96,4 +96,6 @@
         assert(ym1.index()   == 2);
     }
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp
@@ -51,7 +51,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
@@ -116,4 +116,6 @@
     }
     }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp
@@ -45,7 +45,7 @@
 #include <iostream>
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_weekday = std::chrono::year_month_weekday;
     using year                = std::chrono::year;
@@ -53,4 +53,6 @@
     using weekday             = std::chrono::weekday;
 
     std::cout << year_month_weekday{year{2018}, month{3}, weekday{4}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_weekday = std::chrono::year_month_weekday;
 
     static_assert(std::is_trivially_copyable_v<year_month_weekday>, "");
     static_assert(std::is_standard_layout_v<year_month_weekday>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp
@@ -28,7 +28,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -48,4 +48,6 @@
     static_assert( ym1.weekday_last() == weekday_last{Tuesday}, "");
     static_assert( ym1.ok(),                                    "");
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -37,4 +37,6 @@
         year_month_weekday_last ymd(year{1234}, month{i}, weekday_last{weekday{}});
         assert( static_cast<unsigned>(ymd.month()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -69,4 +69,6 @@
         year_month_weekday_last ym{year{i}, January, weekday_last{Tuesday}};
         assert((ym.ok() == year{i}.ok()));
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                = std::chrono::year;
     using month_day_last      = std::chrono::month_day_last;
@@ -57,4 +57,6 @@
 
     assert(sd.time_since_epoch() == days{-(10957+33)});
     }
+
+    return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
@@ -22,7 +22,7 @@
 
 #include <iostream>
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -65,4 +65,6 @@
 
     assert(sd.time_since_epoch() == days{-(10957+35)});
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -71,4 +71,6 @@
         assert(ymwd.year()     == y);
         assert(ymwd.weekday()  == Tuesday);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp
@@ -32,7 +32,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -72,4 +72,6 @@
         assert(ymwd.month()    == January);
         assert(ymwd.weekday()  == Tuesday);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -37,4 +37,6 @@
         year_month_weekday_last ymwdl(year{1}, month{1}, weekday_last{weekday{i}});
         assert(static_cast<unsigned>(ymwdl.weekday()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -37,4 +37,6 @@
         year_month_weekday_last ymwdl(year{i}, month{1}, weekday_last{weekday{}});
         assert(static_cast<int>(ymwdl.year()) == i);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -110,4 +110,6 @@
             year_month_weekday_last{year{i}, January, weekday_last{Tuesday}},
             year_month_weekday_last{year{j}, January, weekday_last{Tuesday}},
             i == j)));
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp
@@ -40,7 +40,7 @@
     return true;
 }
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -89,4 +89,6 @@
     }
     }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp
@@ -47,7 +47,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
@@ -112,4 +112,6 @@
     }
     }
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_weekday_last = std::chrono::year_month_weekday_last;
     using year                    = std::chrono::year;
@@ -34,4 +34,6 @@
     using weekday_last            = std::chrono::weekday_last;
 
     std::cout << year_month_weekday_last{year{2018}, month{3}, weekday_last{weekday{4}}};
+
+  return 0;
 }
Index: test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp
+++ test/std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp
@@ -16,10 +16,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using year_month_weekday_last = std::chrono::year_month_weekday_last;
 
     static_assert(std::is_trivially_copyable_v<year_month_weekday_last>, "");
     static_assert(std::is_standard_layout_v<year_month_weekday_last>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp
+++ test/std/utilities/time/time.clock.req/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/nothing_to_do.pass.cpp
+++ test/std/utilities/time/time.clock/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
@@ -27,7 +27,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock C;
     static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
@@ -35,4 +35,6 @@
     static_assert((std::is_same<C::duration, C::time_point::duration>::value), "");
     static_assert(C::is_steady || !C::is_steady, "");
     test(std::chrono::high_resolution_clock::is_steady);
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.hires/now.pass.cpp
@@ -15,11 +15,13 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::high_resolution_clock C;
     C::time_point t1 = C::now();
     assert(t1.time_since_epoch().count() != 0);
     assert(C::time_point::min() < t1);
     assert(C::time_point::max() > t1);
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp
@@ -22,7 +22,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::file_clock C;
     static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
@@ -31,4 +31,6 @@
     static_assert((std::is_same<C::time_point::clock, C>::value), "");
     static_assert(!C::is_steady, "");
     test(std::chrono::file_clock::is_steady);
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp
@@ -21,8 +21,10 @@
   ASSERT_SAME_TYPE(std::chrono::file_time<Dur>, std::chrono::time_point<std::chrono::file_clock, Dur>);
 }
 
-int main() {
+int main(int, char**) {
   test<std::chrono::nanoseconds>();
   test<std::chrono::minutes>();
   test<std::chrono::hours>();
+
+  return 0;
 }
\ No newline at end of file
Index: test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::file_clock C;
     ASSERT_NOEXCEPT(C::now());
@@ -31,4 +31,6 @@
     assert(t1.time_since_epoch().count() != 0);
     assert(C::time_point::min() < t1);
     assert(C::time_point::max() > t1);
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp
@@ -20,9 +20,11 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     static_assert(std::is_signed<std::chrono::file_clock::rep>::value, "");
     assert(std::chrono::file_clock::duration::min() <
            std::chrono::file_clock::duration::zero());
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
@@ -29,7 +29,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::steady_clock C;
     static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
@@ -37,4 +37,6 @@
     static_assert((std::is_same<C::duration, C::time_point::duration>::value), "");
     static_assert(C::is_steady, "");
     test(std::chrono::steady_clock::is_steady);
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.steady/now.pass.cpp
@@ -17,10 +17,12 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::steady_clock C;
     C::time_point t1 = C::now();
     C::time_point t2 = C::now();
     assert(t2 >= t1);
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
@@ -27,7 +27,7 @@
 template <class T>
 void test(const T &) {}
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock C;
     static_assert((std::is_same<C::rep, C::duration::rep>::value), "");
@@ -36,4 +36,6 @@
     static_assert((std::is_same<C::time_point::clock, C>::value), "");
     static_assert((C::is_steady || !C::is_steady), "");
     test(std::chrono::system_clock::is_steady);
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.system/from_time_t.pass.cpp
@@ -15,9 +15,11 @@
 #include <chrono>
 #include <ctime>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock C;
     C::time_point t1 = C::from_time_t(C::to_time_t(C::now()));
     ((void)t1);
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using local_t = std::chrono::local_t;
     using year    = std::chrono::year;
@@ -61,4 +61,6 @@
     ASSERT_SAME_TYPE(decltype(s0.time_since_epoch()), seconds);
     assert( s0.time_since_epoch().count() == 0);
     assert( s1.time_since_epoch().count() == 946684800L);
+
+    return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.system/now.pass.cpp
@@ -15,11 +15,13 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock C;
     C::time_point t1 = C::now();
     assert(t1.time_since_epoch().count() != 0);
     assert(C::time_point::min() < t1);
     assert(C::time_point::max() > t1);
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.system/rep_signed.pass.cpp
@@ -15,8 +15,10 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     assert(std::chrono::system_clock::duration::min() <
            std::chrono::system_clock::duration::zero());
+
+  return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using system_clock = std::chrono::system_clock;
     using year         = std::chrono::year;
@@ -60,4 +60,6 @@
     ASSERT_SAME_TYPE(decltype(s0.time_since_epoch()), seconds);
     assert( s0.time_since_epoch().count() == 0);
     assert( s1.time_since_epoch().count() == 946684800L);
+
+    return 0;
 }
Index: test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp
===================================================================
--- test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp
+++ test/std/utilities/time/time.clock/time.clock.system/to_time_t.pass.cpp
@@ -15,9 +15,11 @@
 #include <chrono>
 #include <ctime>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock C;
     std::time_t t1 = C::to_time_t(C::now());
     ((void)t1);
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/default_ratio.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/default_ratio.pass.cpp
+++ test/std/utilities/time/time.duration/default_ratio.pass.cpp
@@ -18,8 +18,10 @@
 #include <chrono>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::chrono::duration<int, std::ratio<1> >,
                    std::chrono::duration<int> >::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/duration.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/duration.fail.cpp
+++ test/std/utilities/time/time.duration/duration.fail.cpp
@@ -15,8 +15,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::duration<std::chrono::milliseconds> D;
     D d;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/positive_num.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/positive_num.fail.cpp
+++ test/std/utilities/time/time.duration/positive_num.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::duration<int, std::ratio<5, -1> > D;
     D d;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/ratio.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/ratio.fail.cpp
+++ test/std/utilities/time/time.duration/ratio.fail.cpp
@@ -22,8 +22,10 @@
     static const int den = D;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::duration<int, Ratio<1> > D;
     D d;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.alg/abs.fail.cpp
@@ -20,7 +20,9 @@
 
 typedef std::chrono::duration<unsigned> unsigned_secs;
 
-int main()
+int main(int, char**)
 {
     std::chrono::abs(unsigned_secs(0));
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.alg/abs.pass.cpp
@@ -30,7 +30,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::milliseconds( 7290000));
@@ -46,4 +46,6 @@
     constexpr std::chrono::hours h2 = std::chrono::abs(std::chrono::hours(3));
     static_assert(h2.count() == 3, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
@@ -25,7 +25,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::hours h(3);
@@ -37,4 +37,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
@@ -26,7 +26,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::hours h1(3);
@@ -38,4 +38,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::chrono::minutes m(3);
@@ -42,4 +42,6 @@
     static_assert( (std::is_same< decltype(zero+one), D1>::value), "");
     static_assert( (std::is_same< decltype(+one),     D1>::value), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
@@ -28,7 +28,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s(3);
@@ -41,4 +41,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp
@@ -25,7 +25,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::hours h(3);
@@ -37,4 +37,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp
@@ -27,7 +27,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::hours h1(3);
@@ -39,4 +39,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     const std::chrono::minutes m(3);
@@ -43,4 +43,6 @@
     static_assert( (std::is_same< decltype(-one),     D1>::value), "");
     static_assert( (std::is_same< decltype(+one),     D1>::value), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp
@@ -28,7 +28,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s(3);
@@ -41,4 +41,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp
@@ -26,7 +26,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(15);
@@ -37,4 +37,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp
@@ -27,7 +27,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::microseconds us1(11);
@@ -41,4 +41,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp
@@ -26,7 +26,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::microseconds us(11);
@@ -37,4 +37,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp
@@ -26,7 +26,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(3);
@@ -37,4 +37,6 @@
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.cast/ceil.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::ceil<int>(std::chrono::milliseconds(3));
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cast/ceil.pass.cpp
@@ -32,7 +32,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 3));
@@ -47,4 +47,6 @@
     constexpr std::chrono::hours h2 = std::chrono::ceil<std::chrono::hours>(std::chrono::milliseconds(-9000000));
     static_assert(h2.count() == -2, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp
@@ -32,7 +32,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test(std::chrono::milliseconds(7265000), std::chrono::hours(2));
     test(std::chrono::milliseconds(7265000), std::chrono::minutes(121));
@@ -50,4 +50,6 @@
     static_assert(h.count() == 2, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.cast/floor.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::floor<int>(std::chrono::milliseconds(3));
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cast/floor.pass.cpp
@@ -31,7 +31,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 2));
@@ -46,4 +46,6 @@
     constexpr std::chrono::hours h2 = std::chrono::floor<std::chrono::hours>(std::chrono::milliseconds(-9000000));
     static_assert(h2.count() == -3, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.cast/round.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::round<int>(std::chrono::milliseconds(3));
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cast/round.pass.cpp
@@ -31,7 +31,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 2));
@@ -46,4 +46,6 @@
     constexpr std::chrono::hours h2 = std::chrono::round<std::chrono::hours>(std::chrono::milliseconds(-9000000));
     static_assert(h2.count() == -2, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp
@@ -18,7 +18,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration_cast<int>(std::chrono::milliseconds(3));
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s1(3);
@@ -113,4 +113,6 @@
     static_assert(!(s1 != s2), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp
@@ -35,7 +35,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s1(3);
@@ -151,4 +151,6 @@
     static_assert( (s1 >= s2), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::milliseconds ms(1);
@@ -34,4 +34,6 @@
     static_assert(us.count() == 1000, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp
@@ -17,8 +17,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<double> d;
     std::chrono::duration<int> i = d;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp
@@ -17,8 +17,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::microseconds us(1);
     std::chrono::milliseconds ms = us;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::duration<double, std::micro> us(1);
@@ -34,4 +34,6 @@
     static_assert(ms.count() == 1./1000, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::duration<int> i(3);
@@ -34,4 +34,6 @@
     static_assert(d.count() == 3000, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp
@@ -26,11 +26,13 @@
     called = true;
 }
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::duration<int, std::exa> r(1);
     f(r);
     assert(called);
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp
@@ -32,7 +32,9 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<Rep> >();
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp
@@ -31,10 +31,12 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int> >(5);
     test<std::chrono::duration<int, std::ratio<3, 2> > >(5);
     test<std::chrono::duration<Rep, std::ratio<3, 2> > >(Rep(3));
     test<std::chrono::duration<double, std::ratio<2, 3> > >(5.5);
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp
@@ -19,7 +19,9 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<int> d = 1;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp
@@ -19,7 +19,9 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d(1);
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<double> d(5);
     assert(d.count() == 5);
@@ -28,4 +28,6 @@
     constexpr std::chrono::duration<double> d2(5);
     static_assert(d2.count() == 5, "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp
@@ -17,7 +17,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<int> d(1.);
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp
@@ -15,7 +15,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals::chrono_literals;
 
@@ -57,4 +57,6 @@
     auto ns2 = 645.ns;
     assert ( ns == ns2 );
 
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp
@@ -11,8 +11,10 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::chrono::hours h  = 4h;  // should fail w/conversion operator not found
+
+  return 0;
 }
 
Index: test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp
@@ -11,7 +11,7 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::chrono;
 
@@ -67,4 +67,6 @@
     assert(November  == month(11));
     assert(December  == month(12));
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp
@@ -11,9 +11,11 @@
 #include <chrono>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using std::chrono::hours;
 
     hours foo  =  4h;  // should fail w/conversion operator not found
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp
@@ -13,7 +13,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     using namespace std::literals;
 
@@ -46,4 +46,6 @@
     assert ( ns == std::chrono::nanoseconds(645));
     auto ns2 = 645.ns;
     assert ( ns == ns2 );
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s1(3);
@@ -71,4 +71,6 @@
     static_assert(r.count() == 75, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::seconds s1(3);
@@ -72,4 +72,6 @@
     static_assert(r.count() == -15, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_macros.h"
 #include "truncate_fp.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns1(15);
@@ -65,4 +65,6 @@
     static_assert(s1 / s2 == 20./3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp
@@ -18,8 +18,10 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d(Rep(15));
     d = d / 5;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(15);
@@ -34,4 +34,6 @@
     static_assert(ns2.count() == 3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns1(15);
@@ -60,4 +60,6 @@
     static_assert(r.count() == 24, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp
@@ -18,8 +18,10 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d(Rep(15));
     d = d % 5;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(15);
@@ -34,4 +34,6 @@
     static_assert(ns2.count() == 3, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     std::chrono::nanoseconds ns(3);
@@ -43,4 +43,6 @@
     static_assert(ns3.count() == 18, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp
@@ -22,8 +22,10 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d;
     d = d * 5;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp
+++ test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp
@@ -22,8 +22,10 @@
 
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     std::chrono::duration<Rep> d;
     d = 5 * d;
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp
@@ -40,8 +40,10 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int> >();
     test<std::chrono::duration<Rep> >();
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp
@@ -40,8 +40,10 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int> >();
     test<std::chrono::duration<Rep> >();
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
+++ test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp
@@ -39,8 +39,10 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int> >();
     test<std::chrono::duration<Rep> >();
+
+  return 0;
 }
Index: test/std/utilities/time/time.duration/types.pass.cpp
===================================================================
--- test/std/utilities/time/time.duration/types.pass.cpp
+++ test/std/utilities/time/time.duration/types.pass.cpp
@@ -18,9 +18,11 @@
 #include <chrono>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::duration<long, std::ratio<3, 2> > D;
     static_assert((std::is_same<D::rep, long>::value), "");
     static_assert((std::is_same<D::period, std::ratio<3, 2> >::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/default_duration.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/default_duration.pass.cpp
+++ test/std/utilities/time/time.point/default_duration.pass.cpp
@@ -18,8 +18,10 @@
 #include <chrono>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     static_assert((std::is_same<std::chrono::system_clock::duration,
                    std::chrono::time_point<std::chrono::system_clock>::duration>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/duration.fail.cpp
===================================================================
--- test/std/utilities/time/time.point/duration.fail.cpp
+++ test/std/utilities/time/time.point/duration.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::time_point<std::chrono::system_clock, int> T;
     T t;
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp
+++ test/std/utilities/time/time.point/time.point.arithmetic/op_+=.pass.cpp
@@ -29,7 +29,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::chrono::system_clock Clock;
@@ -42,4 +42,6 @@
 #if TEST_STD_VER > 14
     static_assert(constexpr_test(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp
+++ test/std/utilities/time/time.point/time.point.arithmetic/op_-=.pass.cpp
@@ -29,7 +29,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::chrono::system_clock Clock;
@@ -42,4 +42,6 @@
 #if TEST_STD_VER > 14
     static_assert(constexpr_test(), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
+++ test/std/utilities/time/time.point/time.point.cast/ceil.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::ceil<int>(std::chrono::system_clock::now());
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
+++ test/std/utilities/time/time.point/time.point.cast/ceil.pass.cpp
@@ -49,7 +49,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 3));
@@ -65,4 +65,6 @@
 
     test_constexpr<std::chrono::milliseconds, 9000000, std::chrono::seconds, 9000> ();
     test_constexpr<std::chrono::milliseconds,-9000000, std::chrono::seconds,-9000> ();
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
+++ test/std/utilities/time/time.point/time.point.cast/floor.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::floor<int>(std::chrono::system_clock::now());
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
+++ test/std/utilities/time/time.point/time.point.cast/floor.pass.cpp
@@ -48,7 +48,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 2));
@@ -64,4 +64,6 @@
 
     test_constexpr<std::chrono::milliseconds, 9000000, std::chrono::seconds, 9000> ();
     test_constexpr<std::chrono::milliseconds,-9000000, std::chrono::seconds,-9000> ();
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cast/round.fail.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cast/round.fail.cpp
+++ test/std/utilities/time/time.point/time.point.cast/round.fail.cpp
@@ -19,7 +19,9 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     std::chrono::round<int>(std::chrono::system_clock::now());
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
+++ test/std/utilities/time/time.point/time.point.cast/round.pass.cpp
@@ -48,7 +48,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
 //  7290000ms is 2 hours, 1 minute, and 30 seconds
     test(std::chrono::milliseconds( 7290000), std::chrono::hours( 2));
@@ -64,4 +64,6 @@
 
     test_constexpr<std::chrono::milliseconds, 9000000, std::chrono::seconds, 9000> ();
     test_constexpr<std::chrono::milliseconds,-9000000, std::chrono::seconds,-9000> ();
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp
+++ test/std/utilities/time/time.point/time.point.cast/time_point_cast.pass.cpp
@@ -54,7 +54,7 @@
 
 #endif
 
-int main()
+int main(int, char**)
 {
     test(std::chrono::milliseconds(7265000), std::chrono::hours(2));
     test(std::chrono::milliseconds(7265000), std::chrono::minutes(121));
@@ -78,4 +78,6 @@
     test_constexpr<std::chrono::duration<int, std::ratio<2, 3>>, 9, T1, 10> ();
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp
+++ test/std/utilities/time/time.point/time.point.cast/toduration.fail.cpp
@@ -18,10 +18,12 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::time_point<Clock, std::chrono::milliseconds> FromTimePoint;
     typedef std::chrono::time_point<Clock, std::chrono::minutes> ToTimePoint;
     std::chrono::time_point_cast<ToTimePoint>(FromTimePoint(std::chrono::milliseconds(3)));
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp
+++ test/std/utilities/time/time.point/time.point.comparisons/op_equal.fail.cpp
@@ -24,7 +24,7 @@
 
 #include "../../clock.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock1;
     typedef Clock                     Clock2;
@@ -36,4 +36,6 @@
     T1 t1(Duration1(3));
     T2 t2(Duration2(3000));
     t1 == t2;
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
+++ test/std/utilities/time/time.point/time.point.comparisons/op_equal.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -82,4 +82,6 @@
     static_assert( (t1 != t2), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp
+++ test/std/utilities/time/time.point/time.point.comparisons/op_less.fail.cpp
@@ -32,7 +32,7 @@
 
 #include "../../clock.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock1;
     typedef Clock                     Clock2;
@@ -44,4 +44,6 @@
     T1 t1(Duration1(3));
     T2 t2(Duration2(3000));
     t1 < t2;
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp
+++ test/std/utilities/time/time.point/time.point.comparisons/op_less.pass.cpp
@@ -31,7 +31,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -106,4 +106,6 @@
     static_assert(!(t1 >= t2), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp
+++ test/std/utilities/time/time.point/time.point.cons/convert.fail.cpp
@@ -17,7 +17,7 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -26,4 +26,6 @@
     std::chrono::time_point<Clock, Duration2> t2(Duration2(3));
     std::chrono::time_point<Clock, Duration1> t1 = t2;
     }
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp
+++ test/std/utilities/time/time.point/time.point.cons/convert.pass.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::microseconds Duration1;
@@ -35,4 +35,6 @@
     static_assert(t1.time_since_epoch() == Duration1(3000), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cons/default.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cons/default.pass.cpp
+++ test/std/utilities/time/time.point/time.point.cons/default.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::duration<Rep, std::milli> Duration;
@@ -32,4 +32,6 @@
     static_assert(t.time_since_epoch() == Duration::zero(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp
+++ test/std/utilities/time/time.point/time.point.cons/duration.fail.cpp
@@ -16,9 +16,11 @@
 
 #include <chrono>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
     std::chrono::time_point<Clock, Duration> t = Duration(3);
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp
+++ test/std/utilities/time/time.point/time.point.cons/duration.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
@@ -39,4 +39,6 @@
     static_assert(t.time_since_epoch() == Duration(3000), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp
+++ test/std/utilities/time/time.point/time.point.nonmember/op_+.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -44,4 +44,6 @@
     static_assert(t3.time_since_epoch() == Duration2(3006), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp
+++ test/std/utilities/time/time.point/time.point.nonmember/op_-duration.pass.cpp
@@ -30,7 +30,7 @@
     assert(t1 < t0);
 }
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -49,4 +49,6 @@
 #endif
     test2739<int32_t>();
     test2739<uint32_t>();
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp
+++ test/std/utilities/time/time.point/time.point.nonmember/op_-time_point.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration1;
@@ -36,4 +36,6 @@
     static_assert((t1 - t2) == Duration2(2995), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp
+++ test/std/utilities/time/time.point/time.point.observer/tested_elsewhere.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.special/max.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.special/max.pass.cpp
+++ test/std/utilities/time/time.point/time.point.special/max.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
@@ -27,4 +27,6 @@
     ASSERT_NOEXCEPT(       TP::max());
 #endif
     assert(TP::max() == TP(Duration::max()));
+
+  return 0;
 }
Index: test/std/utilities/time/time.point/time.point.special/min.pass.cpp
===================================================================
--- test/std/utilities/time/time.point/time.point.special/min.pass.cpp
+++ test/std/utilities/time/time.point/time.point.special/min.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
@@ -27,4 +27,6 @@
     ASSERT_NOEXCEPT(       TP::max());
 #endif
     assert(TP::min() == TP(Duration::min()));
+
+  return 0;
 }
Index: test/std/utilities/time/time.traits/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/time/time.traits/nothing_to_do.pass.cpp
+++ test/std/utilities/time/time.traits/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
===================================================================
--- test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
+++ test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::chrono::duration_values<int>::max() ==
            std::numeric_limits<int>::max());
@@ -42,4 +42,6 @@
     ASSERT_NOEXCEPT(std::chrono::duration_values<double>::max());
     ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::max());
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
===================================================================
--- test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
+++ test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::chrono::duration_values<int>::min() ==
            std::numeric_limits<int>::lowest());
@@ -42,4 +42,6 @@
     ASSERT_NOEXCEPT(std::chrono::duration_values<double>::min());
     ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::min());
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
===================================================================
--- test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
+++ test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp
@@ -16,7 +16,7 @@
 #include "test_macros.h"
 #include "../../rep.h"
 
-int main()
+int main(int, char**)
 {
     assert(std::chrono::duration_values<int>::zero() == 0);
     assert(std::chrono::duration_values<Rep>::zero() == 0);
@@ -31,4 +31,6 @@
     ASSERT_NOEXCEPT(std::chrono::duration_values<int>::zero());
     ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::zero());
 #endif
+
+  return 0;
 }
Index: test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
===================================================================
--- test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
+++ test/std/utilities/time/time.traits/time.traits.is_fp/treat_as_floating_point.pass.cpp
@@ -29,7 +29,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     test<int>();
     test<unsigned>();
@@ -39,4 +39,6 @@
     test<double>();
     test<long double>();
     test<A>();
+
+  return 0;
 }
Index: test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp
===================================================================
--- test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp
+++ test/std/utilities/time/time.traits/time.traits.specializations/duration.pass.cpp
@@ -24,7 +24,7 @@
     static_assert((std::is_same<Dc, De>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int, std::ratio<1, 100> >,
          std::chrono::duration<long, std::ratio<1, 1000> >,
@@ -38,4 +38,6 @@
     test<std::chrono::duration<double, std::ratio<21, 1> >,
          std::chrono::duration<short, std::ratio<15, 1> >,
          std::chrono::duration<double, std::ratio<3, 1> > >();
+
+  return 0;
 }
Index: test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp
===================================================================
--- test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp
+++ test/std/utilities/time/time.traits/time.traits.specializations/time_point.pass.cpp
@@ -28,7 +28,7 @@
     static_assert((std::is_same<Tc, Te>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::chrono::duration<int, std::ratio<1, 100> >,
          std::chrono::duration<long, std::ratio<1, 1000> >,
@@ -42,4 +42,6 @@
     test<std::chrono::duration<double, std::ratio<21, 1> >,
          std::chrono::duration<short, std::ratio<15, 1> >,
          std::chrono::duration<double, std::ratio<3, 1> > >();
+
+  return 0;
 }
Index: test/std/utilities/time/weeks.pass.cpp
===================================================================
--- test/std/utilities/time/weeks.pass.cpp
+++ test/std/utilities/time/weeks.pass.cpp
@@ -15,7 +15,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::weeks D;
     typedef D::rep Rep;
@@ -24,4 +24,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 22, "");
     static_assert(std::is_same_v<Period, std::ratio_multiply<std::ratio<7>, std::chrono::days::period>>, "");
+
+  return 0;
 }
Index: test/std/utilities/time/years.pass.cpp
===================================================================
--- test/std/utilities/time/years.pass.cpp
+++ test/std/utilities/time/years.pass.cpp
@@ -15,7 +15,7 @@
 #include <type_traits>
 #include <limits>
 
-int main()
+int main(int, char**)
 {
     typedef std::chrono::years D;
     typedef D::rep Rep;
@@ -24,4 +24,6 @@
     static_assert(std::is_integral<Rep>::value, "");
     static_assert(std::numeric_limits<Rep>::digits >= 17, "");
     static_assert(std::is_same_v<Period, std::ratio_multiply<std::ratio<146097, 400>, std::chrono::days::period>>, "");
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.general/ignore.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.general/ignore.pass.cpp
+++ test/std/utilities/tuple/tuple.general/ignore.pass.cpp
@@ -39,7 +39,7 @@
     return true;
 }
 
-int main() {
+int main(int, char**) {
     {
         constexpr auto& ignore_v = std::ignore;
         ((void)ignore_v);
@@ -50,4 +50,6 @@
     {
         LIBCPP_STATIC_ASSERT(std::is_trivial<decltype(std::ignore)>::value, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
+++ test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
@@ -15,7 +15,7 @@
 #include <tuple>
 #include <memory>
 
-int main () {
+int main(int, char**) {
     {
     std::tuple<std::unique_ptr<char>> up;
     std::tuple<std::shared_ptr<char>> sp;
@@ -29,4 +29,6 @@
     // Smart pointers of type 'T[N]' are not tested here since they are not
     // supported by the standard nor by libc++'s implementation.
     // See https://reviews.llvm.org/D21320 for more information.
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/TupleFunction.pass.cpp
@@ -25,11 +25,13 @@
     void operator()() {}
 };
 
-int main()
+int main(int, char**)
 {
     X x;
     std::function<void()> f(x);
+
+  return 0;
 }
 #else
-int main () {}
+int main(int, char**) { return 0; }
 #endif
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.array.pass.cpp
@@ -40,7 +40,7 @@
     static_assert((std::is_same<typename std::tuple_element<idx, const volatile T>::type, const volatile U>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::array<int, 5>, 5, int, 0>();
     test<std::array<int, 5>, 5, int, 1>();
@@ -48,4 +48,6 @@
     test<std::array<volatile int, 4>, 4, volatile int, 3>();
     test<std::array<char *, 3>, 3, char *, 1>();
     test<std::array<char *, 3>, 3, char *, 2>();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.utility.pass.cpp
@@ -38,7 +38,7 @@
     static_assert((std::is_same<typename std::tuple_element<idx, const volatile T>::type, const volatile U>::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::pair<int, int>, 2, int, 0>();
     test<std::pair<int, int>, 2, int, 1>();
@@ -46,4 +46,6 @@
     test<std::pair<int, volatile int>, 2, volatile int, 1>();
     test<std::pair<char *, int>, 2, char *, 0>();
     test<std::pair<char *, int>, 2, int,    1>();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.fail.cpp
@@ -22,7 +22,7 @@
 #include <tuple>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     using T =  std::tuple<int, long, void*>;
     using E1 = typename std::tuple_element<1, T &>::type; // expected-error{{undefined template}}
@@ -30,4 +30,6 @@
     using E3 = typename std::tuple_element<4, T const>::type;
         // expected-error@__tuple:* 2 {{static_assert failed}}
 
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.pass.cpp
@@ -39,7 +39,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     test<std::tuple<int>, 0, int>();
     test<std::tuple<char, int>, 0, char>();
@@ -47,4 +47,6 @@
     test<std::tuple<int*, char, int>, 0, int*>();
     test<std::tuple<int*, char, int>, 1, char>();
     test<std::tuple<int*, char, int>, 2, int>();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.fail.cpp
@@ -18,9 +18,11 @@
 
 #include <tuple>
 
-int main()
+int main(int, char**)
 {
     (void)std::tuple_size<std::tuple<> &>::value; // expected-error {{implicit instantiation of undefined template}}
     (void)std::tuple_size<int>::value; // expected-error {{implicit instantiation of undefined template}}
     (void)std::tuple_size<std::tuple<>*>::value; // expected-error {{implicit instantiation of undefined template}}
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.pass.cpp
@@ -32,10 +32,12 @@
                                    std::tuple_size<const volatile T> >::value), "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::tuple<>, 0>();
     test<std::tuple<int>, 1>();
     test<std::tuple<char, int>, 2>();
     test<std::tuple<char, char*, int>, 3>();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.fail.cpp
@@ -39,7 +39,7 @@
 template <>
 struct std::tuple_size<Dummy3> {};
 
-int main()
+int main(int, char**)
 {
   // Test that tuple_size<const T> is not incomplete when tuple_size<T>::value
   // is well-formed but not a constant expression.
@@ -59,4 +59,6 @@
     // expected-error@__tuple:* 1 {{no member named 'value'}}
     (void)std::tuple_size<const Dummy3>::value; // expected-note {{here}}
   }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.pass.cpp
@@ -50,7 +50,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
   test_complete<std::tuple<> >();
   test_complete<std::tuple<int&> >();
@@ -63,4 +63,6 @@
   test_incomplete<int>();
   test_incomplete<std::tuple<int>&>();
   test_incomplete<Dummy2>();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp
@@ -139,11 +139,13 @@
   assert(p == -1);
 }
 
-int main() {
+int main(int, char**) {
   test_decomp_user_type();
   test_decomp_tuple();
   test_decomp_pair();
   test_decomp_array();
   test_before_tuple_size_specialization();
   test_after_tuple_size_specialization();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.fail.cpp
@@ -16,10 +16,12 @@
 
 #include <tuple>
 
-int main()
+int main(int, char**)
 {
     (void)std::tuple_size_v<std::tuple<> &>; // expected-note {{requested here}}
     (void)std::tuple_size_v<int>; // expected-note {{requested here}}
     (void)std::tuple_size_v<std::tuple<>*>; // expected-note {{requested here}}
     // expected-error@tuple:* 3 {{implicit instantiation of undefined template}}
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.pass.cpp
@@ -26,7 +26,7 @@
     static_assert(std::tuple_size_v<Tuple const volatile> == std::tuple_size<Tuple>::value, "");
 }
 
-int main()
+int main(int, char**)
 {
     test<std::tuple<>, 0>();
 
@@ -39,4 +39,6 @@
 
     test<std::tuple<int, int, int>, 3>();
     test<std::array<int, 3>, 3>();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_value_sfinae.pass.cpp
@@ -27,7 +27,7 @@
 
 struct Dummy {};
 
-int main() {
+int main(int, char**) {
   // Test that the ::value member does not exist
   static_assert(has_value<std::tuple<int> const>(), "");
   static_assert(has_value<std::pair<int, long> volatile>(), "");
@@ -35,4 +35,6 @@
   static_assert(!has_value<const int>(), "");
   static_assert(!has_value<volatile void>(), "");
   static_assert(!has_value<const volatile std::tuple<int>&>(), "");
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
@@ -265,9 +265,11 @@
     test<13, int const volatile *>();
 }
 
-int main() {
+int main(int, char**) {
     test_constexpr_evaluation();
     test_call_quals_and_arg_types();
     test_return_type();
     test_noexcept();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_extended_types.pass.cpp
@@ -360,7 +360,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         test_ext_int_0<
@@ -422,4 +422,6 @@
           , std::tuple<A_base_2, int, int>, std::tuple<A_base_2 const, int, int>
           >();
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp
@@ -129,7 +129,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     // Instantiate with 1-5 arguments.
     test_all<1>();
@@ -140,4 +140,6 @@
 
     // Stress test with 256
     test_one<256>();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
@@ -205,9 +205,11 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test_constexpr_construction();
     test_perfect_forwarding();
     test_noexcept();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp
@@ -19,7 +19,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, char> T0;
@@ -30,4 +30,6 @@
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == short('a'));
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
@@ -32,7 +32,7 @@
     explicit D(int i = 0) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -85,4 +85,6 @@
         assert(std::get<0>(t) == 43);
         assert(&std::get<0>(t) == &x);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp
@@ -43,7 +43,7 @@
   }
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -106,4 +106,6 @@
         assert(std::get<0>(t) == 43);
         assert(&std::get<0>(t) == &x);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.fail.cpp
@@ -19,7 +19,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<MoveOnly> T;
@@ -27,4 +27,6 @@
         T t;
         t = t0;
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
@@ -35,7 +35,7 @@
   MoveAssignable& operator=(MoveAssignable&&) = default;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -100,4 +100,6 @@
         using T = std::tuple<int, MoveAssignable>;
         static_assert(!std::is_copy_assignable<T>::value, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
@@ -48,7 +48,7 @@
 int CountAssign::moved = 0;
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -122,4 +122,6 @@
         assert(CountAssign::copied == 1);
         assert(CountAssign::moved == 0);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp
@@ -35,7 +35,7 @@
     explicit D(int i) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, std::unique_ptr<D>> T0;
@@ -46,4 +46,6 @@
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1)->id_ == 3);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.assign/tuple_array_template_depth.pass.cpp
@@ -25,9 +25,11 @@
 typedef std::array<char, 1256> array_t;
 typedef std::tuple<array_t> tuple_t;
 
-int main()
+int main(int, char**)
 {
     array_t arr;
     tuple_t tup;
     tup = arr;
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp
@@ -131,7 +131,9 @@
 }
 
 
-int main() {
+int main(int, char**) {
   compile_tests();
   allocator_tests();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp
@@ -78,7 +78,7 @@
   ConvertibleFromInt(int) : state(FromInt) {}
 };
 
-int main()
+int main(int, char**)
 {
     // Test for the creation of dangling references when a tuple is used to
     // store a reference to another tuple as its only element.
@@ -174,4 +174,6 @@
         std::tuple<VT> t2 = {t1};
         assert(std::get<0>(t2).state == VT::FromInt);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp
@@ -57,7 +57,7 @@
 
 };
 
-int main() {
+int main(int, char**) {
     typedef UnconstrainedCtor A;
     typedef ExplicitUnconstrainedCtor ExplicitA;
     {
@@ -94,4 +94,6 @@
         std::tuple<ExplicitA&&> t2(std::forward_as_tuple(ExplicitA{}));
         ((void)t2);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR27684_contains_ref_to_incomplete_type.pass.cpp
@@ -29,7 +29,7 @@
 IncompleteType const& cinc1 = inc1;
 IncompleteType const& cinc2 = inc2;
 
-int main() {
+int main(int, char**) {
     using IT = IncompleteType;
     { // try calling tuple(Tp const&...)
         using Tup = std::tuple<const IT&, const IT&>;
@@ -43,6 +43,8 @@
         assert(&std::get<0>(t) == &inc1);
         assert(&std::get<1>(t) == &inc2);
     }
+
+  return 0;
 }
 
 struct IncompleteType {};
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR31384.pass.cpp
@@ -44,7 +44,7 @@
   explicit operator std::tuple<U>() && { ++count; return {}; }
 };
 
-int main() {
+int main(int, char**) {
   {
     std::tuple<Explicit> foo = Derived<int>{42}; ((void)foo);
     assert(count == 1);
@@ -84,4 +84,6 @@
   }
   count = 0;
 
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
@@ -42,9 +42,11 @@
     bool operator< (const MoveOnly& x) const {return data_ <  x.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<MoveOnly> t = 1;
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
@@ -102,7 +102,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<MoveOnly> t(MoveOnly(0));
@@ -156,4 +156,6 @@
     // Check that SFINAE is properly applied with the default reduced arity
     // constructor extensions.
     test_default_constructible_extension_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
@@ -39,7 +39,7 @@
 
 struct DerivedFromAllocArgT : std::allocator_arg_t {};
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<> t(std::allocator_arg, A1<int>());
@@ -105,4 +105,6 @@
         std::tuple<T, T> t2(42, 42);
         (void)t2;
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp
@@ -77,7 +77,7 @@
   explicit Explicit(int x) : value(x) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<Explicit> t{std::allocator_arg, std::allocator<void>{}, 42};
@@ -148,4 +148,6 @@
     // ensure that the "reduced-arity-initialization" extension is not offered
     // for these constructors.
     test_uses_allocator_sfinae_evaluation();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp
@@ -35,8 +35,10 @@
     return {std::allocator_arg, std::allocator<void>{}, e};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
-int main()
+int main(int, char**)
 {
     const_explicit_copy_test();
     non_const_explicity_copy_test();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp
@@ -40,7 +40,7 @@
     return {std::allocator_arg, std::allocator<void>{}, i};
 }
 
-int main()
+int main(int, char**)
 {
     {
         // check that the literal '0' can implicitly initialize a stored pointer.
@@ -94,4 +94,6 @@
         assert(!alloc_last::allocator_constructed);
         assert(std::get<2>(t) == alloc_last(3));
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_pair.pass.cpp
@@ -23,7 +23,7 @@
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, int> T0;
@@ -55,4 +55,6 @@
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == 3);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp
@@ -36,7 +36,9 @@
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
-int main()
+int main(int, char**)
 {
 
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp
@@ -33,7 +33,7 @@
   Implicit(int x) : value(x) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -86,4 +86,6 @@
         std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, t1};
         assert(std::get<0>(t2).value == 42);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp
@@ -29,7 +29,9 @@
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
-int main()
+int main(int, char**)
 {
 
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp
@@ -49,7 +49,7 @@
   Implicit(int x) : value(x) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<int> T0;
@@ -100,4 +100,6 @@
         std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, std::move(t1)};
         assert(std::get<0>(t2).value == 42);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_copy.pass.cpp
@@ -22,7 +22,7 @@
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -77,4 +77,6 @@
         assert(std::get<2>(t) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move.pass.cpp
@@ -23,7 +23,7 @@
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -76,4 +76,6 @@
         assert(std::get<2>(t) == 3);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_move_pair.pass.cpp
@@ -39,7 +39,7 @@
     explicit D(int i) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, std::unique_ptr<D>> T0;
@@ -51,4 +51,6 @@
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1)->id_ == 3);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
@@ -42,6 +42,8 @@
     // expected-error@-1 {{no viable conversion}}
 }
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.pass.cpp
@@ -76,7 +76,7 @@
     return i;
 }
 
-int main()
+int main(int, char**)
 {
     {
         // check that the literal '0' can implicitly initialize a stored pointer.
@@ -159,4 +159,6 @@
         assert(std::get<3>(t) == 0.0);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types2.fail.cpp
@@ -18,9 +18,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<int, char*, std::string, double&> t(2, nullptr, "text");
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_pair.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, char> T0;
@@ -42,4 +42,6 @@
         static_assert(std::get<1>(t1) == short('a'), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_copy.pass.cpp
@@ -64,7 +64,7 @@
 
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -136,4 +136,6 @@
         std::tuple<Implicit> t2 = t1;
         assert(std::get<0>(t2).value == 42);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_move.pass.cpp
@@ -44,7 +44,7 @@
     explicit D(int i) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
@@ -100,4 +100,6 @@
         std::tuple<Implicit> t2 = std::move(t1);
         assert(std::get<0>(t2).value == 42);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.fail.cpp
@@ -19,11 +19,13 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<MoveOnly> T;
         T t0(MoveOnly(2));
         T t = t0;
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/copy.pass.cpp
@@ -22,7 +22,7 @@
 
 struct Empty {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -66,4 +66,6 @@
         ((void)e); // Prevent unused warning
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
@@ -44,7 +44,7 @@
     int value;
 };
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<> t;
@@ -106,4 +106,6 @@
         IllFormedDefault v(0);
         std::tuple<IllFormedDefault> t(v);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/dtor.pass.cpp
@@ -23,7 +23,7 @@
 #include <cassert>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
   static_assert(std::is_trivially_destructible<
       std::tuple<> >::value, "");
@@ -35,4 +35,6 @@
       std::tuple<std::string> >::value, "");
   static_assert(!std::is_trivially_destructible<
       std::tuple<int, std::string> >::value, "");
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
@@ -149,7 +149,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_primary_template();
   test_empty_specialization();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp
@@ -80,7 +80,7 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -121,4 +121,6 @@
         test_sfinae<move_only_ebo>();
         test_sfinae<move_only_large>();
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move_pair.pass.cpp
@@ -34,7 +34,7 @@
     explicit D(int i) : B(i) {}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<long, std::unique_ptr<D>> T0;
@@ -44,4 +44,6 @@
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1)->id_ == 3);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.pass.cpp
@@ -95,7 +95,9 @@
     assert(std::get<0>(t).value == 42);
 }
 
-int main() {
+int main(int, char**) {
     test_tuple_like_lazy_sfinae();
     test_const_Types_lazy_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/tuple_array_template_depth.pass.cpp
@@ -28,8 +28,10 @@
 typedef std::array<char, 1256> array_t;
 typedef std::tuple<array_t> tuple_t;
 
-int main()
+int main(int, char**)
 {
     array_t arr;
     tuple_t tup(arr);
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.creation/forward_as_tuple.pass.cpp
@@ -64,7 +64,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         test0(std::forward_as_tuple());
@@ -84,4 +84,6 @@
         static_assert ( test3 (std::forward_as_tuple(i, c)) == 2, "" );
 #endif
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp
@@ -21,7 +21,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         int i = 0;
@@ -50,4 +50,6 @@
         static_assert (d1 == 3.14, "" );
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp
@@ -39,7 +39,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         int i = 0;
@@ -60,4 +60,6 @@
         static_assert(test_tie_constexpr(), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.creation/tuple_cat.pass.cpp
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         std::tuple<> t = std::tuple_cat();
@@ -238,4 +238,6 @@
         );
         assert(t2 == std::make_tuple(std::make_tuple(1), std::make_tuple(2)));
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.fail.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<double&, std::string, int> T;
@@ -37,4 +37,6 @@
 
         std::get<1>(t) = "four";
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const.pass.cpp
@@ -24,7 +24,7 @@
 
 struct Empty {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<int> T;
@@ -64,4 +64,6 @@
         assert(std::get<2>(t) == 5);
         assert(d == 2.5);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp
@@ -23,11 +23,13 @@
 
 std::tuple<int> const tup4() { return std::make_tuple(4); }
 
-int main()
+int main(int, char**)
 {
     // LWG2485: tuple should not open a hole in the type system, get() should
     // imitate [expr.ref]'s rules for accessing data members
     {
         cref(std::get<0>(tup4()));  // expected-error {{call to deleted function 'cref'}}
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::tuple<int> T;
@@ -76,4 +76,6 @@
     static_assert(std::get<1>(std::move(t)) == 5, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.elem/get_non_const.pass.cpp
@@ -36,7 +36,7 @@
 constexpr std::tuple<int, int> getP () { return { 3, 4 }; }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<int> T;
@@ -81,4 +81,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.elem/get_rv.pass.cpp
@@ -21,7 +21,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<std::unique_ptr<int> > T;
@@ -29,4 +29,6 @@
         std::unique_ptr<int> p = std::get<0>(std::move(t));
         assert(*p == 3);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
@@ -31,8 +31,10 @@
     upint p = std::get<upint>(t); // expected-error{{deleted copy constructor}}
 }
 
-int main()
+int main(int, char**)
 {
     test_bad_index();
     test_bad_return_type();
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp
@@ -17,7 +17,7 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::complex<float> cf;
     {
@@ -90,4 +90,6 @@
     static_assert(std::get<int>(std::move(t)) == 1, "");
     static_assert(std::get<const int>(std::move(t)) == 2, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp
@@ -22,7 +22,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T1;
@@ -154,4 +154,6 @@
         static_assert(t1 != t2, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.rel/lt.pass.cpp
@@ -34,7 +34,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T1;
@@ -208,4 +208,6 @@
         static_assert(!(t1 >= t2), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -58,4 +58,6 @@
         assert(std::get<1>(t1) == 1);
         assert(std::get<2>(t1) == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "MoveOnly.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -57,4 +57,6 @@
         assert(std::get<1>(t1) == 1);
         assert(std::get<2>(t1) == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp
===================================================================
--- test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp
+++ test/std/utilities/tuple/tuple.tuple/tuple.traits/uses_allocator.pass.cpp
@@ -20,7 +20,7 @@
 
 struct A {};
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::tuple<> T;
@@ -42,4 +42,6 @@
         static_assert((std::is_base_of<std::true_type,
                                        std::uses_allocator<T, A>>::value), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp
+++ test/std/utilities/type.index/type.index.hash/enabled_hash.pass.cpp
@@ -17,6 +17,8 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.hash/hash.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.hash/hash.pass.cpp
+++ test/std/utilities/type.index/type.index.hash/hash.pass.cpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::hash<std::type_index> H;
     static_assert((std::is_same<typename H::argument_type, std::type_index>::value), "" );
@@ -29,4 +29,6 @@
 
     std::type_index t1 = typeid(int);
     assert(std::hash<std::type_index>()(t1) == t1.hash_code());
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.members/ctor.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.members/ctor.pass.cpp
+++ test/std/utilities/type.index/type.index.members/ctor.pass.cpp
@@ -16,9 +16,11 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_info const & info = typeid(int);
     std::type_index t1(info);
     assert(t1.name() == info.name());
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.members/eq.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.members/eq.pass.cpp
+++ test/std/utilities/type.index/type.index.members/eq.pass.cpp
@@ -16,11 +16,13 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_index t1 = typeid(int);
     std::type_index t2 = typeid(int);
     std::type_index t3 = typeid(long);
     assert(t1 == t2);
     assert(t1 != t3);
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.members/hash_code.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.members/hash_code.pass.cpp
+++ test/std/utilities/type.index/type.index.members/hash_code.pass.cpp
@@ -15,9 +15,11 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::type_info& ti = typeid(int);
     std::type_index t1 = typeid(int);
     assert(t1.hash_code() == ti.hash_code());
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.members/lt.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.members/lt.pass.cpp
+++ test/std/utilities/type.index/type.index.members/lt.pass.cpp
@@ -18,7 +18,7 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_index t1 = typeid(int);
     std::type_index t2 = typeid(int);
@@ -41,4 +41,6 @@
         assert( (t1 >  t3));
         assert( (t1 >= t3));
     }
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.members/name.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.members/name.pass.cpp
+++ test/std/utilities/type.index/type.index.members/name.pass.cpp
@@ -16,9 +16,11 @@
 #include <string>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     const std::type_info& ti = typeid(int);
     std::type_index t1 = typeid(int);
     assert(std::string(t1.name()) == ti.name());
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp
+++ test/std/utilities/type.index/type.index.overview/copy_assign.pass.cpp
@@ -15,11 +15,13 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_index t1(typeid(int));
     std::type_index t2(typeid(double));
     assert(t2 != t1);
     t2 = t1;
     assert(t2 == t1);
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp
+++ test/std/utilities/type.index/type.index.overview/copy_ctor.pass.cpp
@@ -15,9 +15,11 @@
 #include <typeindex>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     std::type_index t1(typeid(int));
     std::type_index t2 = t1;
     assert(t2 == t1);
+
+  return 0;
 }
Index: test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
===================================================================
--- test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
+++ test/std/utilities/type.index/type.index.synopsis/hash_type_index.pass.cpp
@@ -22,7 +22,7 @@
 #include "poisoned_hash_helper.hpp"
 #endif
 
-int main()
+int main(int, char**)
 {
   {
     typedef std::hash<std::type_index> H;
@@ -34,4 +34,6 @@
     test_hash_enabled_for_type<std::type_index>(std::type_index(typeid(int)));
   }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utilities.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/utilities.general/nothing_to_do.pass.cpp
+++ test/std/utilities/utilities.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp
+++ test/std/utilities/utility.requirements/allocator.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp
+++ test/std/utilities/utility.requirements/hash.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/utility.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/utility.requirements/nothing_to_do.pass.cpp
+++ test/std/utilities/utility.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp
+++ test/std/utilities/utility.requirements/nullablepointer.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp
+++ test/std/utilities/utility.requirements/swappable.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp
+++ test/std/utilities/utility.requirements/utility.arg.requirements/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/utility/as_const/as_const.fail.cpp
===================================================================
--- test/std/utilities/utility/as_const/as_const.fail.cpp
+++ test/std/utilities/utility/as_const/as_const.fail.cpp
@@ -15,7 +15,9 @@
 
 struct S {int i;};
 
-int main()
+int main(int, char**)
 {
     std::as_const(S{});
+
+  return 0;
 }
Index: test/std/utilities/utility/as_const/as_const.pass.cpp
===================================================================
--- test/std/utilities/utility/as_const/as_const.pass.cpp
+++ test/std/utilities/utility/as_const/as_const.pass.cpp
@@ -34,7 +34,7 @@
     assert(std::as_const<const volatile T>(t) == t);
 }
 
-int main()
+int main(int, char**)
 {
     int i = 3;
     double d = 4.0;
@@ -42,4 +42,6 @@
     test(i);
     test(d);
     test(s);
+
+  return 0;
 }
Index: test/std/utilities/utility/declval/declval.pass.cpp
===================================================================
--- test/std/utilities/utility/declval/declval.pass.cpp
+++ test/std/utilities/utility/declval/declval.pass.cpp
@@ -21,11 +21,13 @@
     A& operator=(const A&);
 };
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     static_assert((std::is_same<decltype(std::declval<A>()), A&&>::value), "");
 #else
     static_assert((std::is_same<decltype(std::declval<A>()), A&>::value), "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/exchange/exchange.pass.cpp
===================================================================
--- test/std/utilities/utility/exchange/exchange.pass.cpp
+++ test/std/utilities/utility/exchange/exchange.pass.cpp
@@ -39,7 +39,7 @@
 
 
 
-int main()
+int main(int, char**)
 {
     {
     int v = 12;
@@ -80,4 +80,6 @@
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/forward/forward.fail.cpp
===================================================================
--- test/std/utilities/utility/forward/forward.fail.cpp
+++ test/std/utilities/utility/forward/forward.fail.cpp
@@ -19,7 +19,7 @@
 A source() {return A();}
 const A csource() {return A();}
 
-int main()
+int main(int, char**)
 {
 #if TEST_STD_VER >= 11
     {
@@ -49,4 +49,6 @@
         A a;
         std::forward(a); // expected-error {{no matching function for call to 'forward'}}
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/forward/forward.pass.cpp
===================================================================
--- test/std/utilities/utility/forward/forward.pass.cpp
+++ test/std/utilities/utility/forward/forward.pass.cpp
@@ -41,7 +41,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     A a;
     const A ca = A();
@@ -87,4 +87,6 @@
     static_assert(std::forward<const int&>(i2) == 42, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/forward/forward_03.pass.cpp
===================================================================
--- test/std/utilities/utility/forward/forward_03.pass.cpp
+++ test/std/utilities/utility/forward/forward_03.pass.cpp
@@ -28,7 +28,7 @@
 one test(A&);
 two test(const A&);
 
-int main()
+int main(int, char**)
 {
     A a;
     const A ca = A();
@@ -54,4 +54,6 @@
     static_assert(sizeof(test(std::forward<const A>(ca))) == 2, "");
     static_assert(sizeof(test(std::forward<const A>(csource()))) == 2, "");
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/forward/move.fail.cpp
===================================================================
--- test/std/utilities/utility/forward/move.fail.cpp
+++ test/std/utilities/utility/forward/move.fail.cpp
@@ -24,10 +24,12 @@
 
 void test(move_only) {}
 
-int main()
+int main(int, char**)
 {
     move_only a;
     const move_only ca = move_only();
 
     test(std::move(ca)); // c
+
+  return 0;
 }
Index: test/std/utilities/utility/forward/move.pass.cpp
===================================================================
--- test/std/utilities/utility/forward/move.pass.cpp
+++ test/std/utilities/utility/forward/move.pass.cpp
@@ -62,7 +62,7 @@
 #endif
 }
 
-int main()
+int main(int, char**)
 {
     { // Test return type and noexcept.
         static_assert(std::is_same<decltype(std::move(x)), int&&>::value, "");
@@ -117,4 +117,6 @@
         static_assert(std::move(y) == 42, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
===================================================================
--- test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
+++ test/std/utilities/utility/forward/move_if_noexcept.pass.cpp
@@ -39,7 +39,7 @@
     legacy(const legacy&);
 };
 
-int main()
+int main(int, char**)
 {
     int i = 0;
     const int ci = 0;
@@ -71,4 +71,6 @@
     static_assert(i2 == 23, "" );
 #endif
 
+
+  return 0;
 }
Index: test/std/utilities/utility/operators/rel_ops.pass.cpp
===================================================================
--- test/std/utilities/utility/operators/rel_ops.pass.cpp
+++ test/std/utilities/utility/operators/rel_ops.pass.cpp
@@ -32,7 +32,7 @@
     return x.data_ < y.data_;
 }
 
-int main()
+int main(int, char**)
 {
     using namespace std::rel_ops;
     A a1(1);
@@ -45,4 +45,6 @@
     assert(a1 <= a2);
     assert(a2 >= a2);
     assert(a2 >= a1);
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/nothing_to_do.pass.cpp
+++ test/std/utilities/utility/pairs/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/get_const.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P;
@@ -26,4 +26,6 @@
         assert(std::get<1>(p) == 4);
         std::get<0>(p) = 5;
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P;
@@ -36,4 +36,6 @@
         static_assert(std::get<1>(p1) == 4, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
     typedef std::pair<std::unique_ptr<int>, short> P;
@@ -62,4 +62,6 @@
     static_assert(std::get<1>(std::move(p1)) == 4, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp
@@ -29,7 +29,7 @@
 constexpr std::pair<int, int> getP () { return { 3, 4 }; }
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P;
@@ -49,4 +49,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp
@@ -20,7 +20,7 @@
 #include <memory>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<int>, short> P;
@@ -28,4 +28,6 @@
         std::unique_ptr<int> ptr = std::get<0>(std::move(p));
         assert(*ptr == 3);
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp
@@ -16,7 +16,7 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::complex<float> cf;
     {
@@ -81,4 +81,6 @@
     static_assert(std::get<int>(std::move(p)) == 1, "");
     static_assert(std::get<const int>(std::move(p)) == 2, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp
@@ -12,9 +12,11 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::complex<float> cf;
     auto t1 = std::make_pair<int, double> ( 42, 3.4 );
     assert (( std::get<cf>(t1) == cf {1,2} ));  // no such type
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp
@@ -12,9 +12,11 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::complex<float> cf;
     auto t1 = std::make_pair<int, int> ( 42, 43 );
     assert ( std::get<int>(t1) == 42 ); // two ints
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp
@@ -12,9 +12,11 @@
 
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     typedef std::unique_ptr<int> upint;
     std::pair<upint, int> t(upint(new int(4)), 23);
     upint p = std::get<upint>(t);
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
@@ -14,8 +14,10 @@
 
 #include <utility>
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<int, short> T;
     std::tuple_element<2, T>::type foo; // expected-error@utility:* {{Index out of bounds in std::tuple_element<std::pair<T1, T2>>}}
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/tuple_element.pass.cpp
@@ -47,8 +47,10 @@
     }
 }
 
-int main()
+int main(int, char**)
 {
     test<int, short>();
     test<int*, char>();
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp
+++ test/std/utilities/utility/pairs/pair.astuple/tuple_size.pass.cpp
@@ -14,7 +14,7 @@
 
 #include <utility>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -32,4 +32,6 @@
         typedef std::pair<int, short> const volatile P1;
         static_assert((std::tuple_size<P1>::value == 2), "");
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp
+++ test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp
@@ -41,7 +41,7 @@
     unsigned get_u2() const {return u2_;}
 };
 
-int main()
+int main(int, char**)
 {
     std::pair<A, B> p(std::piecewise_construct,
                       std::make_tuple(4, 'a'),
@@ -51,4 +51,6 @@
     assert(p.second.get_d() == 3.5);
     assert(p.second.get_u1() == 6u);
     assert(p.second.get_u2() == 2u);
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.general/nothing_to_do.pass.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
@@ -46,7 +46,7 @@
 };
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<int>, short*> P;
@@ -96,4 +96,6 @@
         static_assert(p.second.value == 43, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp
@@ -20,7 +20,7 @@
 #include "archetypes.hpp"
 #endif
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -48,4 +48,6 @@
        assert(p.second.value == -42);
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp
@@ -49,7 +49,7 @@
 struct Incomplete;
 extern Incomplete inc_obj;
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<CopyAssignable, short> P;
@@ -94,6 +94,8 @@
         P p(42, inc_obj);
         assert(&p.second == &inc_obj);
     }
+
+  return 0;
 }
 
 struct Incomplete {};
Index: test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/assign_pair_cxx03.pass.cpp
@@ -27,7 +27,7 @@
 struct Incomplete;
 extern Incomplete inc_obj;
 
-int main()
+int main(int, char**)
 {
     {
     // Test that we don't constrain the assignment operator in C++03 mode.
@@ -42,6 +42,8 @@
     P p(42, inc_obj);
     assert(&p.second == &inc_obj);
     }
+
+  return 0;
 }
 
 struct Incomplete {};
Index: test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
@@ -45,7 +45,7 @@
 int CountAssign::copied = 0;
 int CountAssign::moved = 0;
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<int>, int> P;
@@ -92,4 +92,6 @@
         assert(CountAssign::moved == 1);
         assert(CountAssign::copied == 0);
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp
@@ -29,7 +29,7 @@
 {
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<Derived>, short> P1;
@@ -55,4 +55,6 @@
        assert(p.first == 42);
        assert(p.second.value == -42);
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
@@ -46,7 +46,7 @@
     static_assert(test_convertible<P2,   T2,   T1Arg>() == CanConvert, "");
 }
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<float, short*> P;
@@ -94,4 +94,6 @@
         static_assert(p.second == 10, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
@@ -24,7 +24,7 @@
     bool operator==(const A& a) const {return data_ == a.data_;}
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<float, short*> P;
@@ -38,4 +38,6 @@
         assert(p.first == A(1));
         assert(p.second == 2);
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
@@ -53,7 +53,7 @@
   int value;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, int> P1;
@@ -177,4 +177,6 @@
         static_assert(p2.second.value == 101, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
@@ -15,7 +15,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -25,4 +25,6 @@
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -35,4 +35,6 @@
         static_assert(p2.second == 4, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/default-sfinae.pass.cpp
@@ -139,7 +139,7 @@
 }
 
 
-int main()
+int main(int, char**)
 {
     {
         // Check that pair<T, U> can still be used even if
@@ -160,4 +160,6 @@
         test_is_default_constructible<int>();
         test_is_default_constructible<DefaultSFINAES<int>>();
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
@@ -28,7 +28,7 @@
 #include "test_macros.h"
 #include "archetypes.hpp"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<float, short*> P;
@@ -51,4 +51,6 @@
         static_assert(!std::is_default_constructible<P2>::value, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/dtor.pass.cpp
@@ -26,10 +26,12 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
   static_assert((std::is_trivially_destructible<
       std::pair<int, float> >::value), "");
   static_assert((!std::is_trivially_destructible<
       std::pair<int, std::string> >::value), "");
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
@@ -39,7 +39,7 @@
 // (6)  explicit pair(pair<U1, U2> const&) -> pair<U1, U2>
 // (7)  pair(pair<U1, U2> &&) -> pair<U1, U2>
 // (8)  explicit pair(pair<U1, U2> &&) -> pair<U1, U2>
-int main()
+int main(int, char**)
 {
   using E = ExplicitTestTypes::TestType;
   static_assert(!std::is_convertible<E const&, E>::value, "");
@@ -76,4 +76,6 @@
     std::pair p1(std::move(p));
     ASSERT_SAME_TYPE(decltype(p1), std::pair<std::string, E>);
   }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp
@@ -25,7 +25,7 @@
   Dummy(Dummy &&) = default;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -40,4 +40,6 @@
         static_assert(!std::is_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
@@ -27,7 +27,7 @@
   int value;
 };
 
-int main()
+int main(int, char**)
 {
     {
         using P = std::pair<int, int>;
@@ -53,4 +53,6 @@
         constexpr P U_V = {42, 101}; // expected-error {{must be initialized by a constant expression}}
         constexpr P pair_U_V = other; // expected-error {{must be initialized by a constant expression}}
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp
@@ -21,7 +21,7 @@
 #include <utility>
 
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, int*> P1;
@@ -32,4 +32,6 @@
         assert(p3.first == P1(3, nullptr));
         assert(p3.second == P2(nullptr, 4));
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
@@ -63,7 +63,7 @@
   int value;
 };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<std::unique_ptr<Derived>, int> P1;
@@ -173,4 +173,6 @@
         static_assert(p2.second.value == 43, "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
@@ -120,7 +120,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_constructors_exist();
   test_assignment_operator_exists();
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp
@@ -24,7 +24,7 @@
     bool operator==(int x) const { return i == x; }
     };
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -46,4 +46,6 @@
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/trivial_copy_move.pass.cpp
@@ -26,7 +26,7 @@
   Dummy(Dummy &&) = default;
 };
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<int, short> P;
     {
@@ -52,4 +52,6 @@
 #endif
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.pair/types.pass.cpp
@@ -17,9 +17,11 @@
 #include <utility>
 #include <type_traits>
 
-int main()
+int main(int, char**)
 {
     typedef std::pair<float, short*> P;
     static_assert((std::is_same<P::first_type, float>::value), "");
     static_assert((std::is_same<P::second_type, short*>::value), "");
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp
@@ -23,7 +23,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P;
@@ -94,4 +94,6 @@
         static_assert( (p1 >= p2), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.spec/make_pair.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -49,4 +49,6 @@
     }
 #endif
 
+
+  return 0;
 }
Index: test/std/utilities/utility/pairs/pairs.spec/non_member_swap.pass.cpp
===================================================================
--- test/std/utilities/utility/pairs/pairs.spec/non_member_swap.pass.cpp
+++ test/std/utilities/utility/pairs/pairs.spec/non_member_swap.pass.cpp
@@ -16,7 +16,7 @@
 #include <utility>
 #include <cassert>
 
-int main()
+int main(int, char**)
 {
     {
         typedef std::pair<int, short> P1;
@@ -28,4 +28,6 @@
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/synopsis.pass.cpp
===================================================================
--- test/std/utilities/utility/synopsis.pass.cpp
+++ test/std/utilities/utility/synopsis.pass.cpp
@@ -13,9 +13,11 @@
 
 #include <utility>
 
-int main()
+int main(int, char**)
 {
     std::initializer_list<int> x;
     (void)x;
+
+  return 0;
 }
 
Index: test/std/utilities/utility/utility.inplace/inplace.pass.cpp
===================================================================
--- test/std/utilities/utility/utility.inplace/inplace.pass.cpp
+++ test/std/utilities/utility/utility.inplace/inplace.pass.cpp
@@ -42,7 +42,7 @@
         && std::is_same<Tp, Up>::value;
 }
 
-int main() {
+int main(int, char**) {
     // test in_place_t
     {
         using T = std::in_place_t;
@@ -70,4 +70,6 @@
         static_assert(check_tag<T2>(std::in_place_index<1>));
         static_assert(check_tag<T3>(std::in_place_index<static_cast<size_t>(-1)>));
     }
+
+  return 0;
 }
Index: test/std/utilities/utility/utility.swap/swap.pass.cpp
===================================================================
--- test/std/utilities/utility/utility.swap/swap.pass.cpp
+++ test/std/utilities/utility/utility.swap/swap.pass.cpp
@@ -62,7 +62,7 @@
 }
 #endif
 
-int main()
+int main(int, char**)
 {
 
     {
@@ -99,4 +99,6 @@
         static_assert(noexcept(std::swap(nm, nm)), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/utility/utility.swap/swap_array.pass.cpp
===================================================================
--- test/std/utilities/utility/utility.swap/swap_array.pass.cpp
+++ test/std/utilities/utility/utility.swap/swap_array.pass.cpp
@@ -54,7 +54,7 @@
 #endif
 
 
-int main()
+int main(int, char**)
 {
     {
         int i[3] = {1, 2, 3};
@@ -97,4 +97,6 @@
         static_assert(noexcept(std::swap(ma, ma)), "");
     }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp
+++ test/std/utilities/variant/variant.hash/enabled_hash.pass.cpp
@@ -17,6 +17,8 @@
 
 #include "poisoned_hash_helper.hpp"
 
-int main() {
+int main(int, char**) {
   test_library_hash_specializations_available();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.hash/hash.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.hash/hash.pass.cpp
+++ test/std/utilities/variant/variant.hash/hash.pass.cpp
@@ -150,9 +150,11 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_hash_variant();
   test_hash_variant_duplicate_elements();
   test_hash_monostate();
   test_hash_variant_enabled();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
===================================================================
--- test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
+++ test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
@@ -25,7 +25,9 @@
 #include <type_traits>
 #include <variant>
 
-int main() {
+int main(int, char**) {
     using V = std::variant<int, void *, const void *, long double>;
     std::variant_alternative<4, V>::type foo;  // expected-error@variant:* {{Index out of bounds in std::variant_alternative<>}}
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp
+++ test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp
@@ -55,7 +55,7 @@
                 "");
 }
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int, void *, const void *, long double>;
     test<V, 0, int>();
@@ -73,4 +73,6 @@
     test<V, 4, long double>();
   }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.helpers/variant_size.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.helpers/variant_size.pass.cpp
+++ test/std/utilities/variant/variant.helpers/variant_size.pass.cpp
@@ -36,8 +36,10 @@
                 "");
 };
 
-int main() {
+int main(int, char**) {
   test<std::variant<>, 0>();
   test<std::variant<void *>, 1>();
   test<std::variant<long, long, void *, double>, 4>();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
+++ test/std/utilities/variant/variant.bad_variant_access/bad_variant_access.pass.cpp
@@ -35,11 +35,13 @@
 #include <type_traits>
 #include <variant>
 
-int main() {
+int main(int, char**) {
   static_assert(std::is_base_of<std::exception, std::bad_variant_access>::value,
                 "");
   static_assert(noexcept(std::bad_variant_access{}), "must be noexcept");
   static_assert(noexcept(std::bad_variant_access{}.what()), "must be noexcept");
   std::bad_variant_access ex;
   assert(ex.what());
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp
+++ test/std/utilities/variant/variant.general/nothing_to_do.pass.cpp
@@ -7,4 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main() {}
+int main(int, char**) {
+  return 0;
+}
Index: test/std/utilities/variant/variant.get/get_if_index.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.get/get_if_index.pass.cpp
+++ test/std/utilities/variant/variant.get/get_if_index.pass.cpp
@@ -125,7 +125,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_const_get_if();
   test_get_if();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.get/get_if_type.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.get/get_if_type.pass.cpp
+++ test/std/utilities/variant/variant.get/get_if_type.pass.cpp
@@ -123,7 +123,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_const_get_if();
   test_get_if();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.get/get_index.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.get/get_index.pass.cpp
+++ test/std/utilities/variant/variant.get/get_index.pass.cpp
@@ -285,10 +285,12 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_const_lvalue_get();
   test_lvalue_get();
   test_rvalue_get();
   test_const_rvalue_get();
   test_throws_for_all_value_categories();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.get/get_type.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.get/get_type.pass.cpp
+++ test/std/utilities/variant/variant.get/get_type.pass.cpp
@@ -285,10 +285,12 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_const_lvalue_get();
   test_lvalue_get();
   test_rvalue_get();
   test_const_rvalue_get();
   test_throws_for_all_value_categories();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
+++ test/std/utilities/variant/variant.get/holds_alternative.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include <variant>
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int>;
     constexpr V v;
@@ -34,4 +34,6 @@
     const V v;
     ASSERT_NOEXCEPT(std::holds_alternative<int>(v));
   }
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp
+++ test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp
@@ -23,7 +23,7 @@
 #include <type_traits>
 #include <variant>
 
-int main() {
+int main(int, char**) {
   using M = std::monostate;
   constexpr M m1{};
   constexpr M m2{};
@@ -51,4 +51,6 @@
     static_assert((m1 != m2) == false, "");
     ASSERT_NOEXCEPT(m1 != m2);
   }
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.monostate/monostate.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.monostate/monostate.pass.cpp
+++ test/std/utilities/variant/variant.monostate/monostate.pass.cpp
@@ -16,7 +16,7 @@
 #include <type_traits>
 #include <variant>
 
-int main() {
+int main(int, char**) {
   using M = std::monostate;
   static_assert(std::is_trivially_default_constructible<M>::value, "");
   static_assert(std::is_trivially_copy_constructible<M>::value, "");
@@ -24,4 +24,6 @@
   static_assert(std::is_trivially_destructible<M>::value, "");
   constexpr M m{};
   ((void)m);
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.relops/relops.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.relops/relops.pass.cpp
+++ test/std/utilities/variant/variant.relops/relops.pass.cpp
@@ -269,7 +269,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_equality();
   test_relational();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
===================================================================
--- test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
+++ test/std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
@@ -72,7 +72,7 @@
 }
 
 
-int main() {
+int main(int, char**) {
   using V = std::variant<int, ComparesToMyBoolExplicit>;
   V v1(42);
   V v2(101);
@@ -84,4 +84,6 @@
   (void)(v1 <= v2); // expected-note {{here}}
   (void)(v1 > v2); // expected-note {{here}}
   (void)(v1 >= v2); // expected-note {{here}}
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp
+++ test/std/utilities/variant/variant.synopsis/variant_npos.pass.cpp
@@ -15,6 +15,8 @@
 
 #include <variant>
 
-int main() {
+int main(int, char**) {
   static_assert(std::variant_npos == static_cast<std::size_t>(-1), "");
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
@@ -254,10 +254,12 @@
 #endif // TEST_HAS_NO_EXCEPTIONS
 }
 
-int main() {
+int main(int, char**) {
   test_T_assignment_basic();
   test_T_assignment_performs_construction();
   test_T_assignment_performs_assignment();
   test_T_assignment_noexcept();
   test_T_assignment_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
@@ -590,7 +590,7 @@
 #endif // > C++17
 }
 
-int main() {
+int main(int, char**) {
   test_copy_assignment_empty_empty();
   test_copy_assignment_non_empty_empty();
   test_copy_assignment_empty_non_empty();
@@ -599,4 +599,6 @@
   test_copy_assignment_sfinae();
   test_copy_assignment_not_noexcept();
   test_constexpr_copy_assignment();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
@@ -506,7 +506,7 @@
 #endif // > C++17
 }
 
-int main() {
+int main(int, char**) {
   test_move_assignment_empty_empty();
   test_move_assignment_non_empty_empty();
   test_move_assignment_empty_non_empty();
@@ -515,4 +515,6 @@
   test_move_assignment_sfinae();
   test_move_assignment_noexcept();
   test_constexpr_move_assignment();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
@@ -126,8 +126,10 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_T_ctor_basic();
   test_T_ctor_noexcept();
   test_T_ctor_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
@@ -260,7 +260,7 @@
 #endif // > C++17
 }
 
-int main() {
+int main(int, char**) {
   test_copy_ctor_basic();
   test_copy_ctor_valueless_by_exception();
   test_copy_ctor_sfinae();
@@ -274,4 +274,6 @@
   (void) v2;
 }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp
@@ -122,9 +122,11 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_default_ctor_basic();
   test_default_ctor_sfinae();
   test_default_ctor_noexcept();
   test_default_ctor_throws();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_args.pass.cpp
@@ -104,7 +104,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_basic();
   test_ctor_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp
@@ -110,7 +110,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_basic();
   test_ctor_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_args.pass.cpp
@@ -114,7 +114,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_basic();
   test_ctor_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp
@@ -111,7 +111,9 @@
   }
 }
 
-int main() {
+int main(int, char**) {
   test_ctor_basic();
   test_ctor_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
@@ -331,10 +331,12 @@
 #endif // > C++17
 }
 
-int main() {
+int main(int, char**) {
   test_move_ctor_basic();
   test_move_ctor_valueless_by_exception();
   test_move_noexcept();
   test_move_ctor_sfinae();
   test_constexpr_move_ctor();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp
@@ -44,7 +44,7 @@
 static_assert(!std::is_trivially_copy_constructible<TDtor>::value, "");
 static_assert(std::is_trivially_destructible<TDtor>::value, "");
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int, long, TDtor>;
     static_assert(std::is_trivially_destructible<V>::value, "");
@@ -71,4 +71,6 @@
     assert(NonTDtor::count == 0);
     assert(NonTDtor1::count == 1);
   }
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp
@@ -159,7 +159,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_emplace_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp
@@ -92,7 +92,9 @@
   assert(&ref3 == &std::get<1>(v));
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_emplace_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp
@@ -159,7 +159,9 @@
 #endif
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_emplace_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp
@@ -92,7 +92,9 @@
   assert(&ref3 == &std::get<InitList>(v));
 }
 
-int main() {
+int main(int, char**) {
   test_basic();
   test_emplace_sfinae();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.status/index.pass.cpp
@@ -25,7 +25,7 @@
 #include "variant_test_helpers.hpp"
 
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int, long>;
     constexpr V v;
@@ -57,4 +57,6 @@
     assert(v.index() == std::variant_npos);
   }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
@@ -25,7 +25,7 @@
 #include "variant_test_helpers.hpp"
 
 
-int main() {
+int main(int, char**) {
   {
     using V = std::variant<int, long>;
     constexpr V v;
@@ -50,4 +50,6 @@
     assert(v.valueless_by_exception());
   }
 #endif
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
@@ -589,10 +589,12 @@
 template class std::variant<int, NotSwappable>;
 #endif
 
-int main() {
+int main(int, char**) {
   test_swap_valueless_by_exception();
   test_swap_same_alternative();
   test_swap_different_alternatives();
   test_swap_sfinae();
   test_swap_noexcept();
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant_array.fail.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant_array.fail.cpp
+++ test/std/utilities/variant/variant.variant/variant_array.fail.cpp
@@ -23,10 +23,12 @@
 #include "variant_test_helpers.hpp"
 #include "test_convertible.hpp"
 
-int main()
+int main(int, char**)
 {
     // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, int[]> v; // expected-note {{requested here}}
     std::variant<int, int[42]> v2; // expected-note {{requested here}}
     std::variant<int, int[][42]> v3; // expected-note {{requested here}}
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant_empty.fail.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant_empty.fail.cpp
+++ test/std/utilities/variant/variant.variant/variant_empty.fail.cpp
@@ -18,8 +18,10 @@
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
-int main()
+int main(int, char**)
 {
     // expected-error@variant:* 1 {{static_assert failed}}
     std::variant<> v; // expected-note {{requested here}}
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant_reference.fail.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant_reference.fail.cpp
+++ test/std/utilities/variant/variant.variant/variant_reference.fail.cpp
@@ -18,10 +18,12 @@
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
-int main()
+int main(int, char**)
 {
     // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, int&> v; // expected-note {{requested here}}
     std::variant<int, const int &> v2; // expected-note {{requested here}}
     std::variant<int, int&&> v3; // expected-note {{requested here}}
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.variant/variant_void.fail.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant_void.fail.cpp
+++ test/std/utilities/variant/variant.variant/variant_void.fail.cpp
@@ -23,10 +23,12 @@
 #include "variant_test_helpers.hpp"
 #include "test_convertible.hpp"
 
-int main()
+int main(int, char**)
 {
     // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, void> v; // expected-note {{requested here}}
     std::variant<int, const void> v2; // expected-note {{requested here}}
     std::variant<const volatile void, int> v3; // expected-note {{requested here}}
+
+  return 0;
 }
Index: test/std/utilities/variant/variant.visit/visit.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -310,10 +310,12 @@
   std::visit(Visitor{}, v);
 }
 
-int main() {
+int main(int, char**) {
   test_call_operator_forwarding();
   test_argument_forwarding();
   test_constexpr();
   test_exceptions();
   test_caller_accepts_nonconst();
+
+  return 0;
 }
Index: test/support/nothing_to_do.pass.cpp
===================================================================
--- test/support/nothing_to_do.pass.cpp
+++ test/support/nothing_to_do.pass.cpp
@@ -7,7 +7,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main()
+int main(int, char**)
 {
+
+  return 0;
 }
 
Index: test/support/test.support/test_convertible_header.pass.cpp
===================================================================
--- test/support/test.support/test_convertible_header.pass.cpp
+++ test/support/test.support/test_convertible_header.pass.cpp
@@ -62,6 +62,8 @@
 };
 static_assert(!test_convertible<ExplicitArgs, int, int, int>(), "Must not be convertible");
 
-int main() {
+int main(int, char**) {
     // Nothing to do
+
+  return 0;
 }
Index: test/support/test.support/test_demangle.pass.cpp
===================================================================
--- test/support/test.support/test_demangle.pass.cpp
+++ test/support/test.support/test_demangle.pass.cpp
@@ -14,7 +14,7 @@
 
 template <class T, class U> struct ArgumentListID {};
 
-int main() {
+int main(int, char**) {
   struct {
     const char* raw;
     const char* expect;
@@ -34,4 +34,6 @@
     assert(demangle(raw) == expect);
 #endif
   }
+
+  return 0;
 }
Index: test/support/test.support/test_macros_header_exceptions.fail.cpp
===================================================================
--- test/support/test.support/test_macros_header_exceptions.fail.cpp
+++ test/support/test.support/test_macros_header_exceptions.fail.cpp
@@ -12,7 +12,7 @@
 
 #include "test_macros.h"
 
-int main() {
+int main(int, char**) {
 #if defined(TEST_HAS_NO_EXCEPTIONS)
     try { ((void)0); } catch (...) {} // expected-error {{exceptions disabled}}
 #else
@@ -20,4 +20,6 @@
 #error exceptions enabled
 // expected-error@-1 {{exceptions enabled}}
 #endif
+
+  return 0;
 }
Index: test/support/test.support/test_macros_header_exceptions.pass.cpp
===================================================================
--- test/support/test.support/test_macros_header_exceptions.pass.cpp
+++ test/support/test.support/test_macros_header_exceptions.pass.cpp
@@ -18,6 +18,8 @@
 #error macro defined unexpectedly
 #endif
 
-int main() {
+int main(int, char**) {
     try { ((void)0); } catch (...) {}
+
+  return 0;
 }
Index: test/support/test.support/test_macros_header_rtti.fail.cpp
===================================================================
--- test/support/test.support/test_macros_header_rtti.fail.cpp
+++ test/support/test.support/test_macros_header_rtti.fail.cpp
@@ -15,7 +15,7 @@
 struct A { virtual ~A() {} };
 struct B : A {};
 
-int main() {
+int main(int, char**) {
 #if defined(TEST_HAS_NO_RTTI)
     A* ptr = new B;
     (void)dynamic_cast<B*>(ptr); // expected-error{{cannot use dynamic_cast}}
@@ -25,4 +25,6 @@
 #error RTTI enabled
 // expected-error@-1{{RTTI enabled}}
 #endif
+
+  return 0;
 }
Index: test/support/test.support/test_macros_header_rtti.pass.cpp
===================================================================
--- test/support/test.support/test_macros_header_rtti.pass.cpp
+++ test/support/test.support/test_macros_header_rtti.pass.cpp
@@ -21,8 +21,10 @@
 struct A { virtual ~A() {} };
 struct B : A {};
 
-int main() {
+int main(int, char**) {
     A* ptr = new B;
     (void)dynamic_cast<B*>(ptr);
     delete ptr;
+
+  return 0;
 }
Index: test/support/test.support/test_poisoned_hash_helper.pass.cpp
===================================================================
--- test/support/test.support/test_poisoned_hash_helper.pass.cpp
+++ test/support/test.support/test_poisoned_hash_helper.pass.cpp
@@ -24,6 +24,8 @@
   enum { value = is_complete<std::hash<T> >() };
 };
 
-int main() {
+int main(int, char**) {
   static_assert(LibraryHashTypes::assertTrait<has_complete_hash, false>(), "");
+
+  return 0;
 }
Index: test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp
===================================================================
--- test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp
+++ test/support/test.workarounds/c1xx_broken_is_trivially_copyable.pass.cpp
@@ -25,10 +25,12 @@
   S& operator=(S&&) = delete;
 };
 
-int main() {
+int main(int, char**) {
 #if defined(TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE)
   static_assert(!std::is_trivially_copyable<S>::value, "");
 #else
   static_assert(std::is_trivially_copyable<S>::value, "");
 #endif
+
+  return 0;
 }
Index: test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp
===================================================================
--- test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp
+++ test/support/test.workarounds/c1xx_broken_za_ctor_check.pass.cpp
@@ -31,10 +31,12 @@
 auto test(int) -> decltype(PushFront(std::declval<T>()), std::true_type{});
 auto test(long) -> std::false_type;
 
-int main() {
+int main(int, char**) {
 #if defined(TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK)
     static_assert(!decltype(test(0))::value, "");
 #else
     static_assert(decltype(test(0))::value, "");
 #endif
+
+  return 0;
 }
Index: utils/generate_feature_test_macro_components.py
===================================================================
--- utils/generate_feature_test_macro_components.py
+++ utils/generate_feature_test_macro_components.py
@@ -865,7 +865,7 @@
 
 #endif // TEST_STD_VER > 17
 
-int main() {{}}
+int main(int, char**) { return 0; }
 """.format(script_name=script_name,
            header=h,
            test_tags=test_tags,