[libcxx] [test] Tolerate even more [[nodiscard]] in the STL.

[BillyONeal]

Summary

STL reviewed my [[nodiscard]] changes and suggested a ton more places. These are the associated test changes in libcxx.

[EricWF]

I think I would prefer if this patch "left an explicit trace" as to the reasons for all the (void) casts. Specifically I think a macro like TEST_IGNORE_DISCARD <expr> might be nice.

@BillyONeal What do you think?

Otherwise this LGTM.

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

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

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.
-    std::search_n(Iter(ic), Iter(ic+sc), UserDefinedIntegral<unsigned>(4), 0, count_equal());
+    (void)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
         {
-            m.at(6);
+            (void)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
         {
-            m.at(6);
+            (void)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
         {
-            m.at(6);
+            (void)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
         {
-            m.at(6);
+            (void)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/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
         {
-            c.at(11);
+            (void)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
         {
-            c.at(11);
+            (void)c.at(11);
             assert(false);
         }
         catch (std::out_of_range&)
         {
         }
         assert(c.size() == 4);
 #endif
     }
 #endif
 }

test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::ranlux24 E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     typedef std::ranlux48 E;
     E e1(3);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::ranlux24 E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     typedef std::ranlux48 E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp

 void
 test1()
 {
     std::ranlux24 e1;
     std::ranlux24 e2 = e1;
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     std::ranlux48 e1;
     std::ranlux48 e2 = e1;
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::independent_bits_engine<std::ranlux24, 32, unsigned> E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     typedef std::independent_bits_engine<std::ranlux48, 64, unsigned long long> E;
     E e1(3);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::independent_bits_engine<std::ranlux24, 32, unsigned> E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     typedef std::independent_bits_engine<std::ranlux48, 64, unsigned long long> E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp

 void
 test1()
 {
     std::independent_bits_engine<std::ranlux24, 32, unsigned> e1;
     std::independent_bits_engine<std::ranlux24, 32, unsigned> e2 = e1;
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     std::independent_bits_engine<std::ranlux48, 64, unsigned long long> e1;
     std::independent_bits_engine<std::ranlux48, 64, unsigned long long> e2 = e1;
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::knuth_b E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
 }

test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::knuth_b E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
 }

test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp

 
 int main()
 {
     {
         typedef std::minstd_rand0 Engine;
         typedef std::knuth_b Adaptor;
         Engine e;
         Adaptor a(e);
-        for (unsigned k = 0; k <= Adaptor::table_size; ++k)
-            e();
+        for (unsigned k = 0; k <= Adaptor::table_size; ++k) {
+            (void)e();
+        }
+
         assert(a.base() == e);
     }
 }

test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp

 int main()
 {
     {
         typedef std::minstd_rand0 Engine;
         typedef std::knuth_b Adaptor;
         Engine e;
         Engine e0 = e;
         Adaptor a(std::move(e0));
-        for (unsigned k = 0; k <= Adaptor::table_size; ++k)
-            e();
+        for (unsigned k = 0; k <= Adaptor::table_size; ++k) {
+            (void)e();
+        }
+
         assert(a.base() == e);
     }
 }

test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp

 void
 test1()
 {
     std::knuth_b e1;
     std::knuth_b e2 = e1;
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
 }

test/std/numerics/rand/rand.device/eval.pass.cpp

int main()
         std::random_device::result_type e = r();
         ((void)e); // Prevent unused warning
     }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         std::random_device r("/dev/null");
-        r();
+        (void)r();
         LIBCPP_ASSERT(false);
     }
     catch (const std::system_error&)
     {
     }
 #endif
 }

test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp

 other()
 {
     typedef std::linear_congruential_engine<T, 48271, 123465789, 2147483647> E;
     E e1;
     E e2;
     assert(e1 == e2);
     e1.discard(1);
     assert(e1 != e2);
-    e2();
+    (void)e2();
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 int main()
 {
     rand0<unsigned int>();
     rand0<unsigned long>();
     rand0<unsigned long long>();

test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::mt19937 E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     typedef std::mt19937_64 E;
     E e1(3);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::mt19937 E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     typedef std::mt19937_64 E;
     E e1;
-    e1();
+    (void)e1();
     E e2(e1);
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp

 void
 test1()
 {
     std::mt19937 e1;
     std::mt19937 e2 = e1;
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     std::mt19937_64 e1;
     std::mt19937_64 e2 = e1;
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::ranlux24_base E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     typedef std::ranlux48_base E;
     E e1(3);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp

 #include <random>
 #include <cassert>
 
 void
 test1()
 {
     typedef std::ranlux24_base E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     typedef std::ranlux48_base E;
     E e1;
-    e1();
+    (void)e1();
     E e2(e1);
     assert(e1 == e2);
     assert(e1() == e2());
     E::result_type k = e1();
     assert(e1 != e2);
     assert(e2() == k);
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp

 void
 test1()
 {
     std::ranlux24_base e1;
     std::ranlux24_base e2 = e1;
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 void
 test2()
 {
     std::ranlux48_base e1;
     std::ranlux48_base e2 = e1;
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
 int main()
 {
     test1();
     test2();
 }

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);
-            std::regex_match(s, re);
+            (void)std::regex_match(s, re);
         }
         catch (std::regex_error &) {}
     }
 #else
     ((void)data);
 #endif
 }
 

test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp

int main()
         assert(!l1.locked());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L0 l0;
         L2 l1;
         try
         {
-            std::try_lock(l0, l1);
+            (void)std::try_lock(l0, l1);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
         }
     }
     {
         L2 l0;
         L0 l1;
         try
         {
-            std::try_lock(l0, l1);
+            (void)std::try_lock(l0, l1);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
         }
     }
#if TEST_STD_VER >= 11
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L2 l0;
         L2 l1;
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
#endif
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         L0 l0;
         L0 l1;
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
     {
         L0 l0;
         L2 l1;
         L0 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
     {
         L2 l0;
         L0 l1;
         L0 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
#ifndef TEST_HAS_NO_EXCEPTIONS
         assert(!l2.locked());
     }
     {
         L2 l0;
         L1 l1;
         L1 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
     {
         L2 l0;
         L2 l1;
         L0 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
     {
         L2 l0;
         L0 l1;
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
     {
         L0 l0;
         L2 l1;
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
     {
         L2 l0;
         L2 l1;
         L1 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
     {
         L2 l0;
         L1 l1;
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
     {
         L1 l0;
         L2 l1;
         L2 l2;
         assert(std::try_lock(l0, l1, l2) == 0);
         assert(!l0.locked());
         assert(!l1.locked());
         assert(!l2.locked());
     }
     {
         L0 l0;
         L2 l1;
         L1 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
#ifndef TEST_HAS_NO_EXCEPTIONS
         assert(!l2.locked());
     }
     {
         L2 l0;
         L0 l1;
         L1 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }
     }
     {
         L2 l0;
         L1 l1;
         L0 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
         {
             assert(!l0.locked());
             assert(!l1.locked());
             assert(!l2.locked());
         }

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
     {
-        lk.try_lock();
+        (void)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
     {
-        lk.try_lock();
+        (void)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
     {
-        lk.try_lock_for(ms(5));
+        (void)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
     {
-        lk.try_lock_for(ms(5));
+        (void)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
     {
-        lk.try_lock_until(Clock::now());
+        (void)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
     {
-        lk.try_lock_until(Clock::now());
+        (void)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
     {
-        lk.try_lock();
+        (void)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
     {
-        lk.try_lock();
+        (void)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
     {
-        lk.try_lock_for(ms(5));
+        (void)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
     {
-        lk.try_lock_for(ms(5));
+        (void)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
     {
-        lk.try_lock_until(Clock::now());
+        (void)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
     {
-        lk.try_lock_until(Clock::now());
+        (void)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 {
-        any_cast<Type>(a);
+        (void)any_cast<Type>(a);
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
     } catch (...) {
         assert(false);
     }
 
     try {
-        any_cast<ConstT>(static_cast<any const&>(a));
+        (void)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;
-        any_cast<RefType>(static_cast<any&&>(a));
+        (void)any_cast<RefType>(static_cast<any&&>(a));
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
     } catch (...) {
         assert(false);
     }
 #else
     ((void)a);

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 {
-        a.allocate(count);
+        (void)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 {
-            ptr->shared_from_this();
+            (void)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/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp

 #if TEST_STD_VER > 14
     {
     std::shared_ptr<int> sp1;
     std::shared_ptr<void> sp2;
     std::shared_ptr<long> sp3;
     std::weak_ptr<int> wp1;
 
     std::owner_less<> cmp;
-    cmp(sp1, sp2);
-    cmp(sp1, wp1);
-    cmp(sp1, sp3);
-    cmp(wp1, sp1);
-    cmp(wp1, wp1);
+    assert(!cmp(sp1, sp2));
+    assert(!cmp(sp1, wp1));
+    assert(!cmp(sp1, sp3));
+    assert(!cmp(wp1, sp1));
+    assert(!cmp(wp1, wp1));
     ASSERT_NOEXCEPT(cmp(sp1, sp1));
     ASSERT_NOEXCEPT(cmp(sp1, wp1));
     ASSERT_NOEXCEPT(cmp(wp1, sp1));
     ASSERT_NOEXCEPT(cmp(wp1, wp1));
     }
     {
     // test heterogeneous lookups
     std::set<std::shared_ptr<X>, std::owner_less<>> s;
     std::shared_ptr<void> vp;
     assert(s.find(vp) == s.end());
     }
 #endif
 }