Tests for strings conversions under libcpp-no-exceptions

[rogfer01]

Summary

These files have two styles of tests

// First style
try {
  action
  assert(something-expected);
} catch ( exception ) {
  assert(false);
}

// Second style
try {
  action
  assert(false);
} catch ( exception ) {
  assert(something-expected);
}

Under libcpp-no-exceptions, we still want to run what is inside the try
block (but not the catch) for first style tests. Second style tests are
skipped as a whole.

Conversions from integers only feature second style tests.

The diff is a bit noisy because it still has to skip try keywords
for first style tests. I prefer this to adding a magical TEST_TRY macro
here (catch blocks would look weird and introducing a TEST_CASE macro
does not look appealing to me either)

[rmaprath]

Would it be more cleaner to separate out the exceptions-related tests into their own functions? So, we'd have the two functions test_withexceptions() and test_noexceptions(); the former will only be invoked when testing the normal library variant, the latter will be invoked for all the library variants.

WDYT?

/ Asiri

[EricWF]

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

39 ↗

(On Diff #76373)

Hmm. All of these #ifdefs get ugly fast. I think it might be better to add TEST_TRY and TEST_CATCH(...) macros defined like:

#ifndef TEST_HAS_NO_EXCEPTIONS
#define TEST_TRY try
#define TEST_CATCH(...) catch(__VA_ARGS__)
#else
#define TEST_TRY
#define TEST_CATCH(...) if (false)
#endif

What do you think? Feel free to add those macros to test_macros.h if you like the idea.

[mclow.lists]

I think it might be better to add TEST_TRY and TEST_CATCH(...) macros defined like

@rogfer01 said at the top that he didn't want to add "a magical TEST_TRY macro" - and I agree. Someone tried that in another review, and I nixed it there.

[rmaprath]

In D26139#587587, @mclow.lists wrote:

I think it might be better to add TEST_TRY and TEST_CATCH(...) macros defined like

@rogfer01 said at the top that he didn't want to add "a magical TEST_TRY macro" - and I agree. Someone tried that in another review, and I nixed it there.

I had a proposal for something along those lines in D14653, however those TEST_TRY and TEST_CATCH macros were trying to be "too smart".

I agree, having macros for try and catch sounds to me like it would set the wrong precedent.

[rogfer01]

I'd rather not to go the way of TEST_TRY and TEST_CASE macros.

As suggested by @rmaprath, I've been playing with grouping the tests in three categories: no exceptions (at all), should not throw, must throw. No changes are required for the first group. The third group is easy to protect with just a couple of ifdef / endif. The second group is the noisiest as we still want to run the code inside the try but we need to skip the try keyword and the catch handlers. This approach may be a bit cleaner.

Any further suggestion? I plan to update the patch with the strategy above if no objections arise.

[EricWF]

LGTM. The consensus is against adding TEST_TRY and TEST_CATCH.

libcxx/trunk/test/std/strings/string.conversions/stod.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.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // double stod(const string& str, size_t *idx = 0);
 // double stod(const wstring& str, size_t *idx = 0);
 
 #include <string>
 #include <cmath>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     assert(std::stod("0") == 0);
     assert(std::stod(L"0") == 0);
     assert(std::stod("-0") == 0);
     assert(std::stod(L"-0") == 0);
     assert(std::stod("-10") == -10);
     assert(std::stod(L"-10.5") == -10.5);
     assert(std::stod(" 10") == 10);
     assert(std::stod(L" 10") == 10);
     size_t idx = 0;
     assert(std::stod("10g", &idx) == 10);
     assert(idx == 2);
     idx = 0;
     assert(std::stod(L"10g", &idx) == 10);
     assert(idx == 2);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::stod("1.e60", &idx) == 1.e60);
         assert(idx == 5);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
     try
+#endif
     {
         assert(std::stod(L"1.e60", &idx) == 1.e60);
         assert(idx == 5);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
     idx = 0;
     try
     {
         assert(std::stod("1.e360", &idx) == INFINITY);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
         assert(idx == 0);
     }
     try
     {
         assert(std::stod(L"1.e360", &idx) == INFINITY);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
         assert(idx == 0);
     }
     try
+#endif
     {
         assert(std::stod("INF", &idx) == INFINITY);
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::stod(L"INF", &idx) == INFINITY);
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::isnan(std::stod("NAN", &idx)));
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::isnan(std::stod(L"NAN", &idx)));
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
     idx = 0;
     try
     {
         std::stod("", &idx);
#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::stod(L"a1", &idx);
         assert(false);
     }
     catch (const std::invalid_argument&)
     {
         assert(idx == 0);
     }
+#endif
 }

libcxx/trunk/test/std/strings/string.conversions/stof.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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 
 // <string>
 
 // float stof(const string& str, size_t *idx = 0);
 // float stof(const wstring& str, size_t *idx = 0);
 
 #include <string>
 #include <cmath>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     assert(std::stof("0") == 0);
     assert(std::stof(L"0") == 0);
     assert(std::stof("-0") == 0);
     assert(std::stof(L"-0") == 0);
     assert(std::stof("-10") == -10);
     assert(std::stof(L"-10.5") == -10.5);
     assert(std::stof(" 10") == 10);
     assert(std::stof(L" 10") == 10);
     size_t idx = 0;
     assert(std::stof("10g", &idx) == 10);
     assert(idx == 2);
     idx = 0;
     assert(std::stof(L"10g", &idx) == 10);
     assert(idx == 2);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     idx = 0;
     try
     {
         assert(std::stof("1.e60", &idx) == INFINITY);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
try
         assert(std::stof(L"1.e360", &idx) == INFINITY);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
         assert(idx == 0);
     }
     try
+#endif
     {
         assert(std::stof("INF", &idx) == INFINITY);
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::stof(L"INF", &idx) == INFINITY);
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::isnan(std::stof("NAN", &idx)));
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::isnan(std::stof(L"NAN", &idx)));
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
     idx = 0;
     try
     {
         std::stof("", &idx);
#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::stof(L"a1", &idx);
         assert(false);
     }
     catch (const std::invalid_argument&)
     {
         assert(idx == 0);
     }
+#endif
 }

libcxx/trunk/test/std/strings/string.conversions/stoi.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.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int stoi(const string& str, size_t *idx = 0, int base = 10);
 // int stoi(const wstring& str, size_t *idx = 0, int base = 10);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     assert(std::stoi("0") == 0);
     assert(std::stoi(L"0") == 0);
     assert(std::stoi("-0") == 0);
     assert(std::stoi(L"-0") == 0);
     assert(std::stoi("-10") == -10);
     assert(std::stoi(L"-10") == -10);
     assert(std::stoi(" 10") == 10);
     assert(std::stoi(L" 10") == 10);
     size_t idx = 0;
     assert(std::stoi("10g", &idx, 16) == 16);
     assert(idx == 2);
     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())
     {
         try
         {
             std::stoi("0x100000000", &idx, 16);
             assert(false);
         }
         catch (const std::out_of_range&)
#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::stoi(L"a1", &idx);
         assert(false);
     }
     catch (const std::invalid_argument&)
     {
         assert(idx == 0);
     }
+#endif
 }

libcxx/trunk/test/std/strings/string.conversions/stol.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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 
 // <string>
 
 // long stol(const string& str, size_t *idx = 0, int base = 10);
 // long stol(const wstring& str, size_t *idx = 0, int base = 10);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     assert(std::stol("0") == 0);
     assert(std::stol(L"0") == 0);
     assert(std::stol("-0") == 0);
     assert(std::stol(L"-0") == 0);
     assert(std::stol("-10") == -10);
     assert(std::stol(L"-10") == -10);
     assert(std::stol(" 10") == 10);
     assert(std::stol(L" 10") == 10);
     size_t idx = 0;
     assert(std::stol("10g", &idx, 16) == 16);
     assert(idx == 2);
     idx = 0;
     assert(std::stol(L"10g", &idx, 16) == 16);
     assert(idx == 2);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     idx = 0;
     try
     {
         std::stol("", &idx);
         assert(false);
     }
     catch (const std::invalid_argument&)
     {
//  LWG issue #2009
     {
         std::stol(L"9999999999999999999999999999999999999999999999999", &idx);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
         assert(idx == 0);
     }
+#endif
 }

libcxx/trunk/test/std/strings/string.conversions/stold.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.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // long double stold(const string& str, size_t *idx = 0);
 // long double stold(const wstring& str, size_t *idx = 0);
 
 #include <iostream>
 
 #include <string>
 #include <cmath>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     assert(std::stold("0") == 0);
     assert(std::stold(L"0") == 0);
     assert(std::stold("-0") == 0);
     assert(std::stold(L"-0") == 0);
     assert(std::stold("-10") == -10);
     assert(std::stold(L"-10.5") == -10.5);
     assert(std::stold(" 10") == 10);
     assert(std::stold(L" 10") == 10);
     size_t idx = 0;
     assert(std::stold("10g", &idx) == 10);
     assert(idx == 2);
     idx = 0;
     assert(std::stold(L"10g", &idx) == 10);
     assert(idx == 2);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::stold("1.e60", &idx) == 1.e60L);
         assert(idx == 5);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
     try
+#endif
     {
         assert(std::stold(L"1.e60", &idx) == 1.e60L);
         assert(idx == 5);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         assert(std::stold("1.e6000", &idx) == INFINITY);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
         assert(idx == 0);
     }
     try
     {
         assert(std::stold(L"1.e6000", &idx) == INFINITY);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
         assert(idx == 0);
     }
     try
+#endif
     {
         assert(std::stold("INF", &idx) == INFINITY);
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::stold(L"INF", &idx) == INFINITY);
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::isnan(std::stold("NAN", &idx)));
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
+#endif
     idx = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         assert(std::isnan(std::stold(L"NAN", &idx)));
         assert(idx == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (const std::out_of_range&)
     {
         assert(false);
     }
     idx = 0;
     try
     {
         std::stold("", &idx);
#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::stold(L"a1", &idx);
         assert(false);
     }
     catch (const std::invalid_argument&)
     {
         assert(idx == 0);
     }
+#endif
 }

libcxx/trunk/test/std/strings/string.conversions/stoll.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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 
 // <string>
 
 // long long stoll(const string& str, size_t *idx = 0, int base = 10);
 // long long stoll(const wstring& str, size_t *idx = 0, int base = 10);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     assert(std::stoll("0") == 0);
     assert(std::stoll(L"0") == 0);
     assert(std::stoll("-0") == 0);
     assert(std::stoll(L"-0") == 0);
     assert(std::stoll("-10") == -10);
     assert(std::stoll(L"-10") == -10);
     assert(std::stoll(" 10") == 10);
     assert(std::stoll(L" 10") == 10);
     size_t idx = 0;
     assert(std::stoll("10g", &idx, 16) == 16);
     assert(idx == 2);
     idx = 0;
     assert(std::stoll(L"10g", &idx, 16) == 16);
     assert(idx == 2);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     idx = 0;
     try
     {
         std::stoll("", &idx);
         assert(false);
     }
     catch (const std::invalid_argument&)
     {
#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::stoll(L"99999999999999999999999999", &idx);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
         assert(idx == 0);
     }
+#endif
 }

libcxx/trunk/test/std/strings/string.conversions/stoul.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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 
 // <string>
 
 // unsigned long stoul(const string& str, size_t *idx = 0, int base = 10);
 // unsigned long stoul(const wstring& str, size_t *idx = 0, int base = 10);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     assert(std::stoul("0") == 0);
     assert(std::stoul(L"0") == 0);
     assert(std::stoul("-0") == 0);
     assert(std::stoul(L"-0") == 0);
     assert(std::stoul(" 10") == 10);
     assert(std::stoul(L" 10") == 10);
     size_t idx = 0;
     assert(std::stoul("10g", &idx, 16) == 16);
     assert(idx == 2);
     idx = 0;
     assert(std::stoul(L"10g", &idx, 16) == 16);
     assert(idx == 2);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     idx = 0;
     try
     {
         std::stoul("", &idx);
         assert(false);
     }
     catch (const std::invalid_argument&)
     {
//  LWG issue #2009
     {
         std::stoul(L"9999999999999999999999999999999999999999999999999", &idx);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
         assert(idx == 0);
     }
+#endif
 }

libcxx/trunk/test/std/strings/string.conversions/stoull.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.
 //
 //===----------------------------------------------------------------------===//
 //
-// XFAIL: libcpp-no-exceptions
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin11
 // XFAIL: with_system_cxx_lib=x86_64-apple-darwin12
 
 // <string>
 
 // unsigned long long stoull(const string& str, size_t *idx = 0, int base = 10);
 // unsigned long long stoull(const wstring& str, size_t *idx = 0, int base = 10);
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     assert(std::stoull("0") == 0);
     assert(std::stoull(L"0") == 0);
     assert(std::stoull("-0") == 0);
     assert(std::stoull(L"-0") == 0);
     assert(std::stoull(" 10") == 10);
     assert(std::stoull(L" 10") == 10);
     size_t idx = 0;
     assert(std::stoull("10g", &idx, 16) == 16);
     assert(idx == 2);
     idx = 0;
     assert(std::stoull(L"10g", &idx, 16) == 16);
     assert(idx == 2);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     idx = 0;
     try
     {
         std::stoull("", &idx);
         assert(false);
     }
     catch (const std::invalid_argument&)
     {
//  LWG issue #2009
     {
         std::stoull(L"9999999999999999999999999999999999999999999999999", &idx);
         assert(false);
     }
     catch (const std::out_of_range&)
     {
         assert(idx == 0);
     }
+#endif
 }