Tests ignore the return value of sto{meow}, triggering nodiscard warnings in MS STL

[fsb4000]

correct diff

[Mordante]

Thanks for the patch with a MSVC STL style 🐈.
LGTM!
Do you need me to land it on your behalf?

libcxx/test/std/strings/string.conversions/stod.pass.cpp

60

For future patches can you prove additional content?
Either by using arcanist or git diff -U999999 main. That makes reviewing a bit easier.

[fsb4000]

Do you need me to land it on your behalf?

Yes, thank you for the review on Saturday :)

For future patches can you prove additional content?
Either by using arcanist or git diff -U999999 main. That makes reviewing a bit easier.

Ok, I will use git diff -U999999 main

[Mordante]

In D129925#3657384, @fsb4000 wrote:

Do you need me to land it on your behalf?

Yes, thank you for the review on Saturday :)

You're welcome. I'm a volunteer so Saturday isn't an issue for me ;-)

For future patches can you prove additional content?
Either by using arcanist or git diff -U999999 main. That makes reviewing a bit easier.

Ok, I will use git diff -U999999 main

Thanks!

libcxx/test/std/strings/string.conversions/stod.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
             size_t idx = 0;
             try {
                 assert(std::stod("1.e360", &idx) == INFINITY);
                 assert(false);
             } catch (const std::out_of_range&) {
                 assert(idx == 0);
             }
         }
         {
             size_t idx = 0;
             try {
-                std::stod("", &idx);
+                (void)std::stod("", &idx);
                 assert(false);
             } catch (const std::invalid_argument&) {
                 assert(idx == 0);
             }
         }
         {
             size_t idx = 0;
             try {
-                std::stod("  - 8", &idx);
+                (void)std::stod("  - 8", &idx);
                 assert(false);
             } catch (const std::invalid_argument&) {
                 assert(idx == 0);
             }
         }
         {
             size_t idx = 0;
             try {
-                std::stod("a1", &idx);
+                (void)std::stod("a1", &idx);
                 assert(false);
             } catch (const std::invalid_argument&) {
                 assert(idx == 0);
             }
         }
 #endif // TEST_HAS_NO_EXCEPTIONS
     }
 
#ifndef TEST_HAS_NO_EXCEPTIONS
                 assert(false);
             } catch (const std::out_of_range&) {
                 assert(idx == 0);
             }
         }
         {
             size_t idx = 0;
             try {
-                std::stod(L"", &idx);
+                (void)std::stod(L"", &idx);
                 assert(false);
             } catch (const std::invalid_argument&) {
                 assert(idx == 0);
             }
         }
         {
             size_t idx = 0;
             try {
-                std::stod(L"  - 8", &idx);
+                (void)std::stod(L"  - 8", &idx);
                 assert(false);
             } catch (const std::invalid_argument&) {
                 assert(idx == 0);
             }
         }
         {
             size_t idx = 0;
             try {
-                std::stod(L"a1", &idx);
+                (void)std::stod(L"a1", &idx);
                 assert(false);
             } catch (const std::invalid_argument&) {
                 assert(idx == 0);
             }
         }
 #endif // TEST_HAS_NO_EXCEPTIONS
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/strings/string.conversions/stof.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stof("", &idx);
+            (void)std::stof("", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stof("  - 8", &idx);
+            (void)std::stof("  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stof("a1", &idx);
+            (void)std::stof("a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
#ifndef TEST_HAS_NO_EXCEPTIONS
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stof(L"", &idx);
+            (void)std::stof(L"", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stof(L"  - 8", &idx);
+            (void)std::stof(L"  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stof(L"a1", &idx);
+            (void)std::stof(L"a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/strings/string.conversions/stoi.pass.cpp

assert(std::stoi(" 10") == 10);
         size_t idx = 0;
         assert(std::stoi("10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     if (std::numeric_limits<long>::max() > std::numeric_limits<int>::max()) {
         size_t idx = 0;
         try {
-            std::stoi("0x100000000", &idx, 16);
+            (void)std::stoi("0x100000000", &idx, 16);
             assert(false);
         } catch (const std::out_of_range&) {
 
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoi("", &idx);
+            (void)std::stoi("", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoi("  - 8", &idx);
+            (void)std::stoi("  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoi("a1", &idx);
+            (void)std::stoi("a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     assert(std::stoi(L"0") == 0);
     assert(std::stoi(L"-0") == 0);
     assert(std::stoi(L"-10") == -10);
     assert(std::stoi(L" 10") == 10);
     {
         size_t idx = 0;
         assert(std::stoi(L"10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     if (std::numeric_limits<long>::max() > std::numeric_limits<int>::max()) {
         size_t idx = 0;
         try {
-            std::stoi(L"0x100000000", &idx, 16);
+            (void)std::stoi(L"0x100000000", &idx, 16);
             assert(false);
         } catch (const std::out_of_range&) {
 
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoi(L"", &idx);
+            (void)std::stoi(L"", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoi(L"  - 8", &idx);
+            (void)std::stoi(L"  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoi(L"a1", &idx);
+            (void)std::stoi(L"a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/strings/string.conversions/stol.pass.cpp

assert(std::stol(" 10") == 10);
         size_t idx = 0;
         assert(std::stol("10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stol("", &idx);
+            (void)std::stol("", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stol("  - 8", &idx);
+            (void)std::stol("  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stol("a1", &idx);
+            (void)std::stol("a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
             // LWG#2009 and PR14919
-            std::stol("9999999999999999999999999999999999999999999999999", &idx);
+            (void)std::stol("9999999999999999999999999999999999999999999999999", &idx);
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     assert(std::stol(L"0") == 0);
     assert(std::stol(L"-0") == 0);
     assert(std::stol(L"-10") == -10);
     assert(std::stol(L" 10") == 10);
     {
         size_t idx = 0;
         assert(std::stol(L"10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stol(L"", &idx);
+            (void)std::stol(L"", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stol(L"  - 8", &idx);
+            (void)std::stol(L"  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stol(L"a1", &idx);
+            (void)std::stol(L"a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
             // LWG#2009 and PR14919
-            std::stol(L"9999999999999999999999999999999999999999999999999", &idx);
+            (void)std::stol(L"9999999999999999999999999999999999999999999999999", &idx);
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/strings/string.conversions/stold.pass.cpp

assert(std::stold(" 10") == 10);
         assert(std::isnan(std::stold("NAN", &idx)));
         assert(idx == 3);
     }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stold("", &idx);
+            (void)std::stold("", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stold("  - 8", &idx);
+            (void)std::stold("  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stold("a1", &idx);
+            (void)std::stold("a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
assert(std::stold(L" 10") == 10);
         size_t idx = 0;
         assert(std::isnan(std::stold(L"NAN", &idx)));
         assert(idx == 3);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stold(L"", &idx);
+            (void)std::stold(L"", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stold(L"  - 8", &idx);
+            (void)std::stold(L"  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stold(L"a1", &idx);
+            (void)std::stold(L"a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {

libcxx/test/std/strings/string.conversions/stoll.pass.cpp

assert(std::stoll(" 10") == 10);
         size_t idx = 0;
         assert(std::stoll("10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stoll("", &idx);
+            (void)std::stoll("", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoll("  - 8", &idx);
+            (void)std::stoll("  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoll("a1", &idx);
+            (void)std::stoll("a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
             // LWG#2009 and PR14919
-            std::stoll("99999999999999999999999999", &idx);
+            (void)std::stoll("99999999999999999999999999", &idx);
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     assert(std::stoll(L"0") == 0);
     assert(std::stoll(L"-0") == 0);
     assert(std::stoll(L"-10") == -10);
     assert(std::stoll(L" 10") == 10);
     {
         size_t idx = 0;
         assert(std::stoll(L"10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stoll(L"", &idx);
+            (void)std::stoll(L"", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoll(L"  - 8", &idx);
+            (void)std::stoll(L"  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoll(L"a1", &idx);
+            (void)std::stoll(L"a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
             // LWG#2009 and PR14919
-            std::stoll(L"99999999999999999999999999", &idx);
+            (void)std::stoll(L"99999999999999999999999999", &idx);
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/strings/string.conversions/stoul.pass.cpp

assert(std::stoul(" 10") == 10);
         size_t idx = 0;
         assert(std::stoul("10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stoul("", &idx);
+            (void)std::stoul("", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoul("  - 8", &idx);
+            (void)std::stoul("  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoul("a1", &idx);
+            (void)std::stoul("a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
             // LWG#2009 and PR14919
-            std::stoul("9999999999999999999999999999999999999999999999999", &idx);
+            (void)std::stoul("9999999999999999999999999999999999999999999999999", &idx);
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     assert(std::stoul(L"0") == 0);
     assert(std::stoul(L"-0") == 0);
     assert(std::stoul(L" 10") == 10);
     {
         size_t idx = 0;
         assert(std::stoul(L"10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stoul(L"", &idx);
+            (void)std::stoul(L"", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoul(L"  - 8", &idx);
+            (void)std::stoul(L"  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoul(L"a1", &idx);
+            (void)std::stoul(L"a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
             // LWG#2009 and PR14919
-            std::stoul(L"9999999999999999999999999999999999999999999999999", &idx);
+            (void)std::stoul(L"9999999999999999999999999999999999999999999999999", &idx);
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/strings/string.conversions/stoull.pass.cpp

assert(std::stoull(" 10") == 10);
         size_t idx = 0;
         assert(std::stoull("10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stoull("", &idx);
+            (void)std::stoull("", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoull("  - 8", &idx);
+            (void)std::stoull("  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoull("a1", &idx);
+            (void)std::stoull("a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
             // LWG#2009 and PR14919
-            std::stoull("9999999999999999999999999999999999999999999999999", &idx);
+            (void)std::stoull("9999999999999999999999999999999999999999999999999", &idx);
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     assert(std::stoull(L"0") == 0);
     assert(std::stoull(L"-0") == 0);
     assert(std::stoull(L" 10") == 10);
     {
         size_t idx = 0;
         assert(std::stoull(L"10g", &idx, 16) == 16);
         assert(idx == 2);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     {
         size_t idx = 0;
         try {
-            std::stoull(L"", &idx);
+            (void)std::stoull(L"", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoull(L"  - 8", &idx);
+            (void)std::stoull(L"  - 8", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
-            std::stoull(L"a1", &idx);
+            (void)std::stoull(L"a1", &idx);
             assert(false);
         } catch (const std::invalid_argument&) {
             assert(idx == 0);
         }
     }
     {
         size_t idx = 0;
         try {
             // LWG#2009 and PR14919
-            std::stoull(L"9999999999999999999999999999999999999999999999999", &idx);
+            (void)std::stoull(L"9999999999999999999999999999999999999999999999999", &idx);
             assert(false);
         } catch (const std::out_of_range&) {
             assert(idx == 0);
         }
     }
 #endif // TEST_HAS_NO_EXCEPTIONS
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }