[libcxx] [test] Change (void)s to TEST_IGNORE_NODISCARD as requested by Eric.

[BillyONeal]

Summary

Added the TEST_IGNORE_NODISCARD macro to test_macros.h.
grep test/std for (void) casts that look like they're suppressing [[nodiscard]] and change them to TEST_IGNORE_NODISCARD.

[EricWF]

LGTM.

[BillyONeal]

Committed r318804

test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp

test()
     assert(std::search_n(Iter(ic), Iter(ic+sc), 3, 0, count_equal()) == Iter(ic));
     assert(count_equal::count <= sc);
     count_equal::count = 0;
     assert(std::search_n(Iter(ic), Iter(ic+sc), 4, 0, count_equal()) == Iter(ic+sc));
     assert(count_equal::count <= sc);
     count_equal::count = 0;
 
     // Check that we properly convert the size argument to an integral.
-    (void)std::search_n(Iter(ic), Iter(ic+sc), UserDefinedIntegral<unsigned>(4), 0, count_equal());
+    TEST_IGNORE_NODISCARD std::search_n(Iter(ic), Iter(ic+sc), UserDefinedIntegral<unsigned>(4), 0, count_equal());
     count_equal::count = 0;
 }
 
 int main()
 {
     test<forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
 }

test/std/containers/associative/map/map.access/at.pass.cpp

int main()
         assert(m.at(1) == -1.5);
         assert(m.at(2) == 2.5);
         assert(m.at(3) == 3.5);
         assert(m.at(4) == 4.5);
         assert(m.at(5) == 5.5);
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void)m.at(6);
+            TEST_IGNORE_NODISCARD m.at(6);
             assert(false);
         }
         catch (std::out_of_range&)
         {
         }
 #endif
         assert(m.at(7) == 7.5);
         assert(m.at(8) == 8.5);
#endif
         assert(m.at(1) == 1.5);
         assert(m.at(2) == 2.5);
         assert(m.at(3) == 3.5);
         assert(m.at(4) == 4.5);
         assert(m.at(5) == 5.5);
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void)m.at(6);
+            TEST_IGNORE_NODISCARD m.at(6);
             assert(false);
         }
         catch (std::out_of_range&)
         {
         }
 #endif
         assert(m.at(7) == 7.5);
         assert(m.at(8) == 8.5);
#if TEST_STD_VER >= 11
         assert(m.at(1) == -1.5);
         assert(m.at(2) == 2.5);
         assert(m.at(3) == 3.5);
         assert(m.at(4) == 4.5);
         assert(m.at(5) == 5.5);
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void)m.at(6);
+            TEST_IGNORE_NODISCARD m.at(6);
             assert(false);
         }
         catch (std::out_of_range&)
         {
         }
 #endif
         assert(m.at(7) == 7.5);
         assert(m.at(8) == 8.5);
#endif
         assert(m.at(1) == 1.5);
         assert(m.at(2) == 2.5);
         assert(m.at(3) == 3.5);
         assert(m.at(4) == 4.5);
         assert(m.at(5) == 5.5);
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void)m.at(6);
+            TEST_IGNORE_NODISCARD m.at(6);
             assert(false);
         }
         catch (std::out_of_range&)
         {
         }
 #endif
         assert(m.at(7) == 7.5);
         assert(m.at(8) == 8.5);
         assert(m.size() == 7);
     }
 #endif
 }

test/std/containers/associative/map/map.ops/count1.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    (void)M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/count2.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    (void)M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/count3.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    (void)M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/equal_range1.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    (void)M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/equal_range2.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    (void)M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/equal_range3.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    (void)M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/find1.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    (void)M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/find2.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    (void)M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/find3.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    (void)M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    (void)M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    (void)M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    (void)M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    (void)M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    (void)M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    (void)M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp

 #if TEST_STD_VER <= 11
 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    (void)M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp

 #if TEST_STD_VER <= 11
 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    (void)M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp

 #if TEST_STD_VER <= 11
 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    (void)M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp

 #if TEST_STD_VER <= 11
 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    (void)M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    (void)M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    (void)M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    (void)M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    (void)M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    (void)M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    (void)M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    (void)M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    (void)M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    (void)M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    (void)M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp

 #error "This test requires is C++14 (or later)"
 #else
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    (void)M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/sequences/array/at.pass.cpp

int main()
         C::reference r2 = c.at(2);
         assert(r2 == 3.5);
         r2 = 7.5;
         assert(c.back() == 7.5);
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void) c.at(3);
+            TEST_IGNORE_NODISCARD  c.at(3);
             assert(false);
         }
         catch (const std::out_of_range &) {}
 #endif
     }
     {
         typedef double T;
         typedef std::array<T, 3> C;
         const C c = {1, 2, 3.5};
         C::const_reference r1 = c.at(0);
         assert(r1 == 1);
 
         C::const_reference r2 = c.at(2);
         assert(r2 == 3.5);
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void) c.at(3);
+            TEST_IGNORE_NODISCARD  c.at(3);
             assert(false);
         }
         catch (const std::out_of_range &) {}
 #endif
     }
 
 #if TEST_STD_VER > 11
     {

test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp

#endif
             P(2, "four"),
         };
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.size() == 4);
         assert(c.at(1) == "one");
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void)c.at(11);
+            TEST_IGNORE_NODISCARD c.at(11);
             assert(false);
         }
         catch (std::out_of_range&)
         {
         }
         assert(c.size() == 4);
 #endif
     }
#endif
             P(2, "four"),
         };
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.size() == 4);
         assert(c.at(1) == "one");
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void)c.at(11);
+            TEST_IGNORE_NODISCARD c.at(11);
             assert(false);
         }
         catch (std::out_of_range&)
         {
         }
         assert(c.size() == 4);
 #endif
     }
 #endif
 }

test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <system_error>
 // class error_code
 
 // Make sure that the error_code bits of <system_error> are self-contained.
 
 #include <system_error>
+#include "test_macros.h"
 
 int main()
 {
     std::error_code x;
-    (void) x.category();   // returns a std::error_category &
-    (void) x.default_error_condition(); // std::error_condition
-    (void) x.message();    // returns a std::string
+    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
 }

test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <system_error>
 // class error_condition
 
 // Make sure that the error_condition bits of <system_error> are self-contained.
 
 #include <system_error>
+#include "test_macros.h"
 
 int main()
 {
     std::error_condition x = std::errc(0);
-    (void) x.category();   // returns a std::error_condition &
-    (void) x.message();    // returns a std::string
+    TEST_IGNORE_NODISCARD  x.category();   // returns a std::error_condition &
+    TEST_IGNORE_NODISCARD  x.message();    // returns a std::string
 }

test/std/iterators/iterator.range/begin-end.fail.cpp

namespace Foo {
     FakeIter cend  (const FakeContainer &)  { return 12; }
     FakeIter crbegin(const FakeContainer &) { return 13; }
     FakeIter crend  (const FakeContainer &) { return 14; }
 }
 
 
 int main(){
 // Bug #28927 - shouldn't find these via ADL
-    (void) std::cbegin (Foo::FakeContainer());
-    (void) std::cend   (Foo::FakeContainer());
-    (void) std::crbegin(Foo::FakeContainer());
-    (void) std::crend  (Foo::FakeContainer());
+    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());
 }
 #endif

test/std/iterators/iterators.general/gcc_workaround.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Tests workaround for  https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64816.
 
 #include <string>
+#include "test_macros.h"
 
-void f(const std::string &s) { (void)s.begin(); }
+void f(const std::string &s) { TEST_IGNORE_NODISCARD s.begin(); }
 
 #include <vector>
 
-void AppendTo(const std::vector<char> &v) { (void)v.begin(); }
+void AppendTo(const std::vector<char> &v) { TEST_IGNORE_NODISCARD v.begin(); }
 
 int main() {}

test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp

 //   typedef void                   difference_type;
 //   typedef void                   reference;
 //   typedef void                   pointer;
 // };
 
 #include <iterator>
 #include <type_traits>
 #include <vector>
+#include "test_macros.h"
 
 template <class C>
 struct find_members
     : private std::insert_iterator<C>
 {
     explicit find_members(C& c) : std::insert_iterator<C>(c, c.begin()) {}
     void test()
     {
         this->container = 0;
-        (void)(this->iter == this->iter);
+        TEST_IGNORE_NODISCARD (this->iter == this->iter);
     }
 };
 
 template <class C>
 void
 test()
 {
     typedef std::insert_iterator<C> R;

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp

int main()
     test(input_iterator<char*>(s+5));
     test(forward_iterator<char*>(s+5));
     test(bidirectional_iterator<char*>(s+5));
     test(random_access_iterator<char*>(s+5));
     test(s+5);
     }
     {
     int a[] = {1,2,3,4};
-    (void)std::make_move_iterator(a+4);
-    (void)std::make_move_iterator(a); // test for LWG issue 2061
+    TEST_IGNORE_NODISCARD std::make_move_iterator(a+4);
+    TEST_IGNORE_NODISCARD std::make_move_iterator(a); // test for LWG issue 2061
     }
 
 #if TEST_STD_VER > 14
     {
     constexpr const char *p = "123456789";
     constexpr auto iter = std::make_move_iterator<const char *>(p);
     static_assert(iter.base() == p);
     }
 #endif
 }

test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp

 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
 #include <numeric>
 #include <cassert>
 #include <climits>
 #include <cstdint>
 #include <cstdlib>
 #include <type_traits>
+#include "test_macros.h"
 
 constexpr struct {
   int x;
   int y;
   int expect;
 } Cases[] = {
     {0, 0, 0},
     {1, 0, 0},
int main()
     assert((do_test<int, long>(non_cce)));
     assert((do_test<long, int>(non_cce)));
     assert((do_test<int, long long>(non_cce)));
     assert((do_test<long long, int>(non_cce)));
 
 //  LWG#2837
     {
     auto res1 = std::lcm(static_cast<std::int64_t>(1234), INT32_MIN);
-    (void)std::lcm(INT_MIN, 2UL);   // this used to trigger UBSAN
+    TEST_IGNORE_NODISCARD std::lcm(INT_MIN, 2UL);   // this used to trigger UBSAN
     static_assert(std::is_same_v<decltype(res1), std::int64_t>, "");
     assert(res1 == 1324997410816LL);
     }
 }

test/std/re/re.alg/re.alg.search/grep.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
     size_t size = strlen(data);
     if (size > 0)
     {
         try
         {
             std::regex::flag_type flag = std::regex_constants::grep;
             std::string s((const char *)data, size);
             std::regex re(s, flag);
-            (void)std::regex_match(s, re);
+            TEST_IGNORE_NODISCARD std::regex_match(s, re);
         }
         catch (std::regex_error &) {}
     }
 #else
     ((void)data);
 #endif
 }
 

test/std/re/re.grammar/excessive_brace_count.pass.cpp

 
 #include <regex>
 #include <cassert>
 
 int main() {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::basic, std::regex::grep}) {
     try {
-      (void)std::regex("a\\{100000000000000000\\}", op);
+      TEST_IGNORE_NODISCARD std::regex("a\\{100000000000000000\\}", op);
       assert(false);
     } catch (const std::regex_error &e) {
       assert(e.code() == std::regex_constants::error_badbrace);
     }
   }
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
     try {
-      (void)std::regex("a{100000000000000000}", op);
+      TEST_IGNORE_NODISCARD std::regex("a{100000000000000000}", op);
       assert(false);
     } catch (const std::regex_error &e) {
       assert(e.code() == std::regex_constants::error_badbrace);
     }
   }
   return 0;
 }

test/std/strings/basic.string/string.access/at.pass.cpp

if (pos < s.size())
         assert(s.at(pos) == s[pos]);
         assert(cs.at(pos) == cs[pos]);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
-            (void)s.at(pos);
+            TEST_IGNORE_NODISCARD s.at(pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos >= s.size());
         }
         try
         {
-            (void)cs.at(pos);
+            TEST_IGNORE_NODISCARD cs.at(pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos >= s.size());
         }
     }
 #endif

test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp

test(const S& s, typename S::size_type pos1, typename S::size_type n1,
     static_assert((!std::is_same<S, SV>::value), "");
     if (pos1 <= s.size() && pos2 <= sv.size())
         assert(sign(s.compare(pos1, n1, sv, pos2, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
-            (void)s.compare(pos1, n1, sv, pos2, n2);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > sv.size());
         }
     }
 #endif
 }
 
 template <class S, class SV>
 void
 test_npos(const S& s, typename S::size_type pos1, typename S::size_type n1,
           SV sv,      typename S::size_type pos2, int x)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     if (pos1 <= s.size() && pos2 <= sv.size())
         assert(sign(s.compare(pos1, n1, sv, pos2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
-            (void)s.compare(pos1, n1, sv, pos2);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > sv.size());
         }
     }
 #endif

test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp

 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, str)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
-            (void)s.compare(pos1, n1, str);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos1 > s.size());
         }
     }
 #endif

test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp

 {
     if (pos <= s.size())
         assert(sign(s.compare(pos, n1, str, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
-            (void)s.compare(pos, n1, str, n2);
+            TEST_IGNORE_NODISCARD s.compare(pos, n1, str, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos > s.size());
         }
     }
 #endif

test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp

 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, str)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
-            (void)s.compare(pos1, n1, str);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos1 > s.size());
         }
     }
 #endif

test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp

 {
     if (pos1 <= s.size() && pos2 <= str.size())
         assert(sign(s.compare(pos1, n1, str, pos2, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
-            (void)s.compare(pos1, n1, str, pos2, n2);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > str.size());
         }
     }
 #endif
 }
 
 template <class S>
 void
 test_npos(const S& s,   typename S::size_type pos1, typename S::size_type n1,
           const S& str, typename S::size_type pos2, int x)
 {
     if (pos1 <= s.size() && pos2 <= str.size())
         assert(sign(s.compare(pos1, n1, str, pos2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
-            (void)s.compare(pos1, n1, str, pos2);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > str.size());
         }
     }
 #endif

test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp

 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, sv)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {
         try
         {
-            (void)s.compare(pos1, n1, sv);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos1 > s.size());
         }
     }
 #endif

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp

 {
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
     assert(try_lock_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock();
+        TEST_IGNORE_NODISCARD lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock() == false);
     assert(try_lock_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock();
+        TEST_IGNORE_NODISCARD lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp

 {
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
     assert(try_lock_for_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock_for(ms(5));
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock_for(ms(5)) == false);
     assert(try_lock_for_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock_for(ms(5));
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp

int main()
     typedef std::chrono::steady_clock Clock;
     std::shared_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_until(Clock::now()) == true);
     assert(try_lock_until_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock_until(Clock::now());
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock_until(Clock::now()) == false);
     assert(try_lock_until_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock_until(Clock::now());
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp

 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock() == true);
     assert(try_lock_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock();
+        TEST_IGNORE_NODISCARD lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock() == false);
     assert(try_lock_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock();
+        TEST_IGNORE_NODISCARD lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp

 {
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_for(ms(5)) == true);
     assert(try_lock_for_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock_for(ms(5));
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock_for(ms(5)) == false);
     assert(try_lock_for_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock_for(ms(5));
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp

int main()
     typedef std::chrono::steady_clock Clock;
     std::unique_lock<mutex> lk(m, std::defer_lock);
     assert(lk.try_lock_until(Clock::now()) == true);
     assert(try_lock_until_called == true);
     assert(lk.owns_lock() == true);
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock_until(Clock::now());
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EDEADLK);
     }
 #endif
     lk.unlock();
     assert(lk.try_lock_until(Clock::now()) == false);
     assert(try_lock_until_called == false);
     assert(lk.owns_lock() == false);
     lk.release();
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        (void)lk.try_lock_until(Clock::now());
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
     {
         assert(e.code().value() == EPERM);
     }
 #endif
 }

test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

void test_cast_return_type() {
     static_assert(std::is_same<decltype(any_cast<int const&&>(ca)), int const&&>::value, "");
 }
 
 template <class Type, class ConstT = Type>
 void checkThrows(any& a)
 {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
     try {
-        (void)any_cast<Type>(a);
+        TEST_IGNORE_NODISCARD any_cast<Type>(a);
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
     } catch (...) {
         assert(false);
     }
 
     try {
-        (void)any_cast<ConstT>(static_cast<any const&>(a));
+        TEST_IGNORE_NODISCARD any_cast<ConstT>(static_cast<any const&>(a));
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
     } catch (...) {
         assert(false);
     }
 
     try {
         using RefType = typename std::conditional<
             std::is_lvalue_reference<Type>::value,
             typename std::remove_reference<Type>::type&&,
             Type
         >::type;
-        (void)any_cast<RefType>(static_cast<any&&>(a));
+        TEST_IGNORE_NODISCARD any_cast<RefType>(static_cast<any&&>(a));
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
     } catch (...) {
         assert(false);
     }
 #else
-    ((void)a);
+    (TEST_IGNORE_NODISCARD a);
 #endif
 }
 
 void test_cast_empty() {
     // None of these operations should allocate.
-    DisableAllocationGuard g; ((void)g);
+    DisableAllocationGuard g; (TEST_IGNORE_NODISCARD g);
     any a;
     checkThrows<int>(a);
 }
 
 template <class Type>
 void test_cast_to_reference() {
     assert(Type::count == 0);
     Type::reset();

test/std/utilities/any/any.nonmembers/make_any.pass.cpp

 };
 static_assert(!IsSmallObject<LargeThrows>::value, "");
 
 template <class Type>
 void test_make_any_throws()
 {
     {
         try {
-            (void)std::make_any<Type>(101);
+            TEST_IGNORE_NODISCARD std::make_any<Type>(101);
             assert(false);
         } catch (int const&) {
         }
     }
     {
         try {
-            (void)std::make_any<Type>({1, 2, 3}, 101);
+            TEST_IGNORE_NODISCARD std::make_any<Type>({1, 2, 3}, 101);
             assert(false);
         } catch (int const&) {
         }
     }
 }
 
 #endif
 

test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp

 
 #include "test_macros.h"
 
 template <typename T>
 void test_max(size_t count)
 {
     std::allocator<T> a;
     try {
-        (void)a.allocate(count);
+        TEST_IGNORE_NODISCARD a.allocate(count);
         assert(false);
     } catch (const std::exception &) {
     }
 }
 
 template <typename T>
 void test()
 {

test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp

// is replaced.
             weak = s;
             assert(!weak.expired());
         }
         assert(weak.expired());
         weak.reset();
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
-            (void)ptr->shared_from_this();
+            TEST_IGNORE_NODISCARD ptr->shared_from_this();
             assert(false);
         } catch (std::bad_weak_ptr const&) {
         } catch (...) { assert(false); }
 #endif
         {
             std::shared_ptr<T> s2(ptr, &nullDeleter);
             assert(ptr->shared_from_this() == s2);
         }

test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp

 // test op*()
 
 #include <memory>
 #include <cassert>
 
 int main() {
   std::unique_ptr<int[]> p(new int(3));
   const std::unique_ptr<int[]>& cp = p;
-  (void)(*p);  // expected-error {{indirection requires pointer operand ('std::unique_ptr<int []>' invalid)}}
-  (void)(*cp); // expected-error {{indirection requires pointer operand ('const std::unique_ptr<int []>' invalid)}}
+  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)}}
 }

test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp

 
 #include <tuple>
 #include <string>
 
 struct UserType {};
 
 void test_bad_index() {
     std::tuple<long, long, char, std::string, char, UserType, char> t1;
-    (void)std::get<int>(t1); // expected-error@tuple:* {{type not found}}
-    (void)std::get<long>(t1); // expected-note {{requested here}}
-    (void)std::get<char>(t1); // expected-note {{requested here}}
+    TEST_IGNORE_NODISCARD std::get<int>(t1); // expected-error@tuple:* {{type not found}}
+    TEST_IGNORE_NODISCARD std::get<long>(t1); // expected-note {{requested here}}
+    TEST_IGNORE_NODISCARD std::get<char>(t1); // expected-note {{requested here}}
         // expected-error@tuple:* 2 {{type occurs more than once}}
     std::tuple<> t0;
-    (void)std::get<char*>(t0); // expected-node {{requested here}}
+    TEST_IGNORE_NODISCARD std::get<char*>(t0); // expected-node {{requested here}}
         // expected-error@tuple:* 1 {{type not in empty type list}}
 }
 
 void test_bad_return_type() {
     typedef std::unique_ptr<int> upint;
     std::tuple<upint> t;
     upint p = std::get<upint>(t); // expected-error{{deleted copy constructor}}
 }
 
 int main()
 {
     test_bad_index();
     test_bad_return_type();
 }

test/std/utilities/variant/variant.get/get_index.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
   V v1(42l);
   const V &cv1 = v1;
   assert(v1.index() == 1);
   std::integral_constant<size_t, 0> zero;
   std::integral_constant<size_t, 1> one;
   auto test = [](auto idx, auto &&v) {
     using Idx = decltype(idx);
     try {
-      (void)std::get<Idx::value>(std::forward<decltype(v)>(v));
+      TEST_IGNORE_NODISCARD std::get<Idx::value>(std::forward<decltype(v)>(v));
     } catch (const std::bad_variant_access &) {
       return true;
     } catch (...) { /* ... */
     }
     return false;
   };
   { // lvalue test cases
     assert(test(one, v0));

test/std/utilities/variant/variant.get/get_type.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
   V v1(42l);
   const V &cv1 = v1;
   assert(v1.index() == 1);
   identity<int> zero;
   identity<long> one;
   auto test = [](auto idx, auto &&v) {
     using Idx = decltype(idx);
     try {
-      (void)std::get<typename Idx::type>(std::forward<decltype(v)>(v));
+      TEST_IGNORE_NODISCARD std::get<typename Idx::type>(std::forward<decltype(v)>(v));
     } catch (const std::bad_variant_access &) {
       return true;
     } catch (...) { /* ... */
     }
     return false;
   };
   { // lvalue test cases
     assert(test(one, v0));

test/support/test_macros.h

 #else
 #define LIBCPP_ASSERT(...) ((void)0)
 #define LIBCPP_STATIC_ASSERT(...) ((void)0)
 #define LIBCPP_ASSERT_NOEXCEPT(...) ((void)0)
 #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ((void)0)
 #define LIBCPP_ONLY(...) ((void)0)
 #endif
 
+#define TEST_IGNORE_NODISCARD (void)
+
 namespace test_macros_detail {
 template <class T, class U>
 struct is_same { enum { value = 0};} ;
 template <class T>
 struct is_same<T, T> { enum {value = 1}; };
 } // namespace test_macros_detail
 
 #define ASSERT_SAME_TYPE(...) \