16 #define GETTEXT_DOMAIN "wesnoth-test" 
   21 #include <boost/test/unit_test.hpp> 
   29 #pragma warning(disable:4702) 
   32 #define LEXICAL_CAST_DEBUG 
   49     char, 
signed char, 
unsigned char,
 
   50     short, int, long, 
long long,
 
   51     unsigned short, 
unsigned int, 
unsigned long, 
unsigned long long 
   70                 << 
"Expected " << result << 
'\n';
 
   77 template<
typename Test, 
typename... Types>
 
   78 constexpr 
bool contains_type(std::tuple<Types...>)
 
   80     return (std::is_same_v<Test, Types> || ...);
 
   85 #define TEST_CASE(type_send)                           \ 
   87     type_send val = value;                              \ 
   89     BOOST_CHECK_EXCEPTION(                                          \ 
   90             lexical_cast<std::string>(val), const char*, validate); \ 
   97     result = 
"specialized - To std::string - From arithmetic";
 
  112     result = 
"specialized - To arithmetic - From string";
 
  114     const char* value = 
"test";
 
  115     BOOST_CHECK_EXCEPTION(lexical_cast<T>(
 
  117     BOOST_CHECK_EXCEPTION(lexical_cast<T>(
 
  118             const_cast<char*
>(value)), 
const char*, 
validate);
 
  119     BOOST_CHECK_EXCEPTION(lexical_cast<T>(
 
  120             std::string(value)), 
const char*, 
validate);
 
  121     BOOST_CHECK_EXCEPTION(lexical_cast<T>(
 
  122             std::string_view(value)), 
const char*, 
validate);
 
  127     result = 
"specialized - To bool - From string";
 
  129     const char* value = 
"test";
 
  130     BOOST_CHECK_EXCEPTION(lexical_cast<bool>(
 
  132     BOOST_CHECK_EXCEPTION(lexical_cast<bool>(
 
  133             const_cast<char*
>(value)), 
const char*, 
validate);
 
  134     BOOST_CHECK_EXCEPTION(lexical_cast<bool>(
 
  135             std::string(value)), 
const char*, 
validate);
 
  136     BOOST_CHECK_EXCEPTION(lexical_cast<bool>(
 
  137             std::string_view(value)), 
const char*, 
validate);
 
  145     BOOST_CHECK_EQUAL(lexical_cast<std::string>(
true), 
"1");
 
  146     BOOST_CHECK_EQUAL(lexical_cast<std::string>(
false), 
"0");
 
  148     BOOST_CHECK_EQUAL(lexical_cast<std::string>(1), 
"1");
 
  149     BOOST_CHECK_EQUAL(lexical_cast<std::string>(1u), 
"1");
 
  151     BOOST_CHECK_EQUAL(lexical_cast<std::string>(1.2f), 
"1.2");
 
  152     BOOST_CHECK_EQUAL(lexical_cast<std::string>(1.2), 
"1.2");
 
  154     BOOST_CHECK_EQUAL(lexical_cast<int>(
"1"), 1);
 
  155     BOOST_CHECK_EQUAL(lexical_cast<int>(
"-1"), -1);
 
  156     BOOST_CHECK_EQUAL(lexical_cast<unsigned>(
"1"), 1);
 
  157     BOOST_CHECK_EQUAL(lexical_cast<double>(
"1.2"), 1.2);
 
  160     BOOST_CHECK_EQUAL(lexical_cast_default<int>(
"80%"), 80);
 
  162     BOOST_CHECK_EQUAL(lexical_cast<double>(
"0x11"), 0);
 
  164     std::string a = 
"01234567890123456789";
 
  165     BOOST_CHECK_EQUAL(lexical_cast<long long>(a), 1234567890123456789ll);
 
  167     BOOST_CHECK_EQUAL(lexical_cast<double>(a), 1.23456789012345678e18);
 
  168     BOOST_CHECK_EQUAL(lexical_cast_default<long long>(a, 0ll), 1234567890123456789ll);
 
  169     BOOST_CHECK_EQUAL(lexical_cast_default<int>(a, 0), 0);
 
  170     BOOST_CHECK_EQUAL(lexical_cast_default<double>(a, 0.0), 1.23456789012345678e18);
 
  172     std::string 
b = 
"99999999999999999999";
 
  175     BOOST_CHECK_EQUAL(lexical_cast<double>(
b), 1e20);
 
  176     BOOST_CHECK_EQUAL(lexical_cast_default<long long>(
b, 0ll), 0ll);
 
  177     BOOST_CHECK_EQUAL(lexical_cast_default<int>(
b, 0), 0);
 
  178     BOOST_CHECK_EQUAL(lexical_cast_default<double>(
b, 0.0), 1e20);
 
static void validate(boost::any &v, const std::vector< std::string > &values, two_strings *, int)
New lexcical_cast header.
Standard logging facilities (interface).
std::tuple< char, signed char, unsigned char, short, int, long, long long, unsigned short, unsigned int, unsigned long, unsigned long long > test_integral_types
BOOST_AUTO_TEST_CASE(test_lexical_cast_bool)
decltype(std::tuple_cat(test_integral_types{}, test_floating_point_types{})) test_arithmetic_types
decltype(std::tuple_cat(test_bool_types{}, test_integral_types{})) test_match_types
std::tuple< float, double, long double > test_floating_point_types
decltype(std::tuple_cat(test_floating_point_types{})) test_nomatch_types
decltype(std::tuple_cat(test_nomatch_types{}, test_match_types{})) test_types
std::tuple< bool > test_bool_types
BOOST_AUTO_TEST_CASE_TEMPLATE(test_lexical_cast_throw, T, test_types)
Thrown when a lexical_cast fails.
#define TEST_CASE(type_send)
BOOST_AUTO_TEST_CASE(test_lexical_cast_result)