[libcxx] [test] Tolerate [[nodiscard]] on STL functions in libcxx tests

[BillyONeal]

Summary

I applied [[nodiscard]] to lots of things in MSVC++'s STL, which trips up some tests in libcxx. This change adds (void) casts or assertions as necessary to make [[nodiscard]] happy.

test/std/containers/associative/map/map.ops/count0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().count(C2Int{5});
+    assert(M().count(C2Int{5}) == 0);
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().count(C2Int{5});
+    assert(M().count(C2Int{5}) == 0);
     }
 }

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;
 
-    M().count(C2Int{5});
+    (void)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;
 
-    M().count(C2Int{5});
+    (void)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;
 
-    M().count(C2Int{5});
+    (void)M().count(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/equal_range0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().equal_range(C2Int{5});
+    typedef std::pair<typename M::iterator, typename M::iterator> P;
+    M example;
+    P result = example.equal_range(C2Int{5});
+    assert(result.first == result.second);
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().equal_range(C2Int{5});
+    typedef std::pair<typename M::iterator, typename M::iterator> P;
+    M example;
+    P result = example.equal_range(C2Int{5});
+    assert(result.first == result.second);
     }
 }

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;
 
-    M().equal_range(C2Int{5});
+    (void)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;
 
-    M().equal_range(C2Int{5});
+    (void)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;
 
-    M().equal_range(C2Int{5});
+    (void)M().equal_range(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/find0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().find(C2Int{5});
+    M example;
+    assert(example.find(C2Int{5}) == example.end());
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().find(C2Int{5});
+    M example;
+    assert(example.find(C2Int{5}) == example.end());
     }
 }

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;
 
-    M().find(C2Int{5});
+    (void)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;
 
-    M().find(C2Int{5});
+    (void)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;
 
-    M().find(C2Int{5});
+    (void)M().find(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().lower_bound(C2Int{5});
+    M example;
+    assert(example.lower_bound(C2Int{5}) == example.end());
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().lower_bound(C2Int{5});
+    M example;
+    assert(example.lower_bound(C2Int{5}) == example.end());
     }
 }

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;
 
-    M().lower_bound(C2Int{5});
+    (void)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;
 
-    M().lower_bound(C2Int{5});
+    (void)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;
 
-    M().lower_bound(C2Int{5});
+    (void)M().lower_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().upper_bound(C2Int{5});
+    M example;
+    assert(example.upper_bound(C2Int{5}) == example.end());
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().upper_bound(C2Int{5});
+    M example;
+    assert(example.upper_bound(C2Int{5}) == example.end());
     }
 }

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;
 
-    M().upper_bound(C2Int{5});
+    (void)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;
 
-    M().upper_bound(C2Int{5});
+    (void)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;
 
-    M().upper_bound(C2Int{5});
+    (void)M().upper_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().count(C2Int{5});
+    assert(M().count(C2Int{5}) == 0);
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().count(C2Int{5});
+    assert(M().count(C2Int{5}) == 0);
     }
 }

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;
 
-    M().count(C2Int{5});
+    (void)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;
 
-    M().count(C2Int{5});
+    (void)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;
 
-    M().count(C2Int{5});
+    (void)M().count(C2Int{5});
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().equal_range(C2Int{5});
+    typedef std::pair<typename M::iterator, typename M::iterator> P;
+    M example;
+    P result = example.equal_range(C2Int{5});
+    assert(result.first == result.second);
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().equal_range(C2Int{5});
+    typedef std::pair<typename M::iterator, typename M::iterator> P;
+    M example;
+    P result = example.equal_range(C2Int{5});
+    assert(result.first == result.second);
     }
 }

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;
 
-    M().equal_range(C2Int{5});
+    (void)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;
 
-    M().equal_range(C2Int{5});
+    (void)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;
 
-    M().equal_range(C2Int{5});
+    (void)M().equal_range(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().find(C2Int{5});
+    M example;
+    assert(example.find(C2Int{5}) == example.end());
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().find(C2Int{5});
+    M example;
+    assert(example.find(C2Int{5}) == example.end());
     }
 }

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;
 
-    M().find(C2Int{5});
+    (void)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;
 
-    M().find(C2Int{5});
+    (void)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;
 
-    M().find(C2Int{5});
+    (void)M().find(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().lower_bound(C2Int{5});
+    M example;
+    assert(example.lower_bound(C2Int{5}) == example.end());
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().lower_bound(C2Int{5});
+    M example;
+    assert(example.lower_bound(C2Int{5}) == example.end());
     }
 }

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;
 
-    M().lower_bound(C2Int{5});
+    (void)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;
 
-    M().lower_bound(C2Int{5});
+    (void)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;
 
-    M().lower_bound(C2Int{5});
+    (void)M().lower_bound(C2Int{5});
     }
 }
 #endif

test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp

 #include <cassert>
 
 #include "is_transparent.h"
 
 int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().upper_bound(C2Int{5});
+    M example;
+    assert(example.upper_bound(C2Int{5}) == example.end());
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().upper_bound(C2Int{5});
+    M example;
+    assert(example.upper_bound(C2Int{5}) == example.end());
     }
 }

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;
 
-    M().upper_bound(C2Int{5});
+    (void)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;
 
-    M().upper_bound(C2Int{5});
+    (void)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;
 
-    M().upper_bound(C2Int{5});
+    (void)M().upper_bound(C2Int{5});
     }
 }
 #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>
 
-void f(const std::string &s) { s.begin(); }
+void f(const std::string &s) { (void)s.begin(); }
 
 #include <vector>
 
-void AppendTo(const std::vector<char> &v) { v.begin(); }
+void AppendTo(const std::vector<char> &v) { (void)v.begin(); }
 
 int main() {}

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};
-    std::make_move_iterator(a+4);
-    std::make_move_iterator(a); // test for LWG issue 2061
+    (void)std::make_move_iterator(a+4);
+    (void)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/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
         {
-            s.at(pos);
+            (void)s.at(pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos >= s.size());
         }
         try
         {
-            cs.at(pos);
+            (void)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
         {
-            s.compare(pos1, n1, sv, pos2, n2);
+            (void)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
         {
-            s.compare(pos1, n1, sv, pos2);
+            (void)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
         {
-            s.compare(pos1, n1, str);
+            (void)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
         {
-            s.compare(pos, n1, str, n2);
+            (void)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
         {
-            s.compare(pos1, n1, str);
+            (void)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
         {
-            s.compare(pos1, n1, str, pos2, n2);
+            (void)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
         {
-            s.compare(pos1, n1, str, pos2);
+            (void)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
         {
-            s.compare(pos1, n1, sv);
+            (void)s.compare(pos1, n1, sv);
             assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos1 > s.size());
         }
     }
 #endif

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

void test ( const CharT *s, size_t len ) {
     std::basic_string_view<CharT> sv ( s, len );
     assert ( sv.length() == len );
     for ( size_t i = 0; i < len; ++i ) {
         assert (  sv.at(i) == s[i] );
         assert ( &sv.at(i) == s + i );
     }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    try { sv.at(len); } catch ( const std::out_of_range & ) { return ; }
+    try { (void)sv.at(len); } catch ( const std::out_of_range & ) { return ; }
     assert ( false );
 #endif
 }
 
 int main () {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 

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

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

test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp

#if TEST_STD_VER > 14
     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;
-    s.find(vp);
+    assert(s.find(vp) == s.end());
     }
 #endif
 }

test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp

int main()
         opt.emplace();
         assert(opt.value().test() == 4);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         optional<X> opt;
         try
         {
-            opt.value();
+            (void)opt.value();
             assert(false);
         }
         catch (const bad_optional_access&)
         {
         }
     }
 #endif
     static_assert(test() == 7, "");
 }

test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp

int main()
         const optional<X> opt(in_place);
         assert(opt.value().test() == 3);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         const optional<X> opt;
         try
         {
-            opt.value();
+            (void)opt.value();
             assert(false);
         }
         catch (const bad_optional_access&)
         {
         }
     }
 #endif
 }

test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp

int main()
         const optional<X> opt(in_place);
         assert(std::move(opt).value().test() == 5);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         const optional<X> opt;
         try
         {
-            std::move(opt).value();
+            (void)std::move(opt).value();
             assert(false);
         }
         catch (const bad_optional_access&)
         {
         }
     }
 #endif
 }

test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp

int main()
         opt.emplace();
         assert(std::move(opt).value().test() == 6);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         optional<X> opt;
         try
         {
-            std::move(opt).value();
+            (void)std::move(opt).value();
             assert(false);
         }
         catch (const bad_optional_access&)
         {
         }
     }
 #endif
     static_assert(test() == 7, "");
 }

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 {
-      std::get<Idx::value>(std::forward<decltype(v)>(v));
+      (void)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 {
-      std::get<typename Idx::type>(std::forward<decltype(v)>(v));
+      (void)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));