ceph/src/boost/libs/convert/test/strtol_converter.cpp

   1 // Boost.Convert test and usage example
   2 // Copyright (c) 2009-2016 Vladimir Batov.
   3 // Use, modification and distribution are subject to the Boost Software License,
   4 // Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
   5
   6 #include "./test.hpp"
   7
   8 #if defined(BOOST_CONVERT_IS_NOT_SUPPORTED)
   9 int main(int, char const* []) { return 0; }
  10 #else
  11
  12 #include <boost/convert.hpp>
  13 #include <boost/convert/printf.hpp>
  14 #include <boost/convert/stream.hpp>
  15 #include <boost/detail/lightweight_test.hpp>
  16 #include <boost/random/mersenne_twister.hpp>
  17 #include <boost/random/uniform_int_distribution.hpp>
  18 #include <boost/random/uniform_01.hpp>
  19 #include <boost/lexical_cast.hpp>
  20 #include <boost/utility/string_view.hpp>
  21
  22 //[strtol_basic_deployment_header
  23 #include <boost/convert.hpp>
  24 #include <boost/convert/strtol.hpp>
  25
  26 using std::string;
  27 using std::wstring;
  28 using boost::convert;
  29
  30 struct boost::cnv::by_default : boost::cnv::strtol {};
  31 //]
  32
  33 static
  34 void
  35 test_str_to_uint()
  36 {
  37     string const         bad_str = "not an int";
  38     string const         neg_str = "-11";
  39     string const         std_str = "11";
  40     char const* const      c_str = "12";
  41     boost::string_view     v_str = boost::string_view(c_str, 1);
  42     unsigned int const      imax = (std::numeric_limits<unsigned int>::max)();
  43     unsigned long int const lmax = (std::numeric_limits<unsigned long int>::max)();
  44     std::string const   imax_str = boost::lexical_cast<std::string>(imax);
  45     std::string const   lmax_str = boost::lexical_cast<std::string>(lmax);
  46
  47     BOOST_TEST( 0 == convert<unsigned int>(bad_str).value_or(0));
  48     BOOST_TEST( 0 == convert<unsigned int>(neg_str).value_or(0));
  49     BOOST_TEST( 0 == convert<unsigned long int>(neg_str).value_or(0));
  50     BOOST_TEST( 0 == convert<unsigned long int>(neg_str).value_or(0));
  51     BOOST_TEST(11 == convert<unsigned int>(std_str).value());
  52     BOOST_TEST(12 == convert<unsigned int>(  c_str).value());
  53     BOOST_TEST( 1 == convert<unsigned int>(  v_str).value_or(0));
  54     BOOST_TEST(11 == convert<unsigned long int>(std_str).value());
  55     BOOST_TEST(12 == convert<unsigned long int>(  c_str).value());
  56     BOOST_TEST(imax == convert<     unsigned int>(imax_str).value());
  57     BOOST_TEST(lmax == convert<unsigned long int>(lmax_str).value());
  58 }
  59
  60 static
  61 void
  62 test_str_to_int()
  63 {
  64     //[strtol_basic_deployment
  65     string const     bad_str = "not an int";
  66     string const     std_str = "-11";
  67     char const* const  c_str = "-12";
  68     boost::string_view v_str = boost::string_view(c_str, 2);
  69
  70     BOOST_TEST( -1 == convert<int>(bad_str).value_or(-1));
  71     BOOST_TEST(-11 == convert<int>(std_str).value());
  72     BOOST_TEST(-12 == convert<int>(  c_str).value());
  73     BOOST_TEST( -1 == convert<int>(  v_str).value_or(0));
  74     //]
  75     wstring const      bad_wstr = L"not an int";
  76     wstring const      wstd_str = L"-11";
  77     wchar_t const* const wc_str = L"-12";
  78
  79     BOOST_TEST( -1 == convert<int>(bad_wstr).value_or(-1));
  80     BOOST_TEST(-11 == convert<int>(wstd_str).value());
  81     BOOST_TEST(-12 == convert<int>(  wc_str).value());
  82 }
  83
  84 static
  85 void
  86 test_int_to_str()
  87 {
  88     short const      s_int = -123;
  89     int const        i_int = -123;
  90     long const       l_int = -123;
  91     long long const ll_int = -123;
  92
  93     BOOST_TEST( "-123" == convert< std::string> ( s_int).value());
  94     BOOST_TEST( "-123" == convert< std::string> ( i_int).value());
  95     BOOST_TEST( "-123" == convert< std::string> ( l_int).value());
  96     BOOST_TEST( "-123" == convert< std::string> (ll_int).value());
  97
  98     BOOST_TEST(L"-123" == convert<std::wstring> ( s_int).value());
  99     BOOST_TEST(L"-123" == convert<std::wstring> ( i_int).value());
 100     BOOST_TEST(L"-123" == convert<std::wstring> ( l_int).value());
 101     BOOST_TEST(L"-123" == convert<std::wstring> (ll_int).value());
 102
 103     int const            imin = std::numeric_limits<int>::min();
 104     int const            imax = std::numeric_limits<int>::max();
 105     long int const       lmin = std::numeric_limits<long int>::min();
 106     long int const       lmax = std::numeric_limits<long int>::max();
 107     long long int const llmin = std::numeric_limits<long long int>::min();
 108     long long int const llmax = std::numeric_limits<long long int>::max();
 109
 110     std::string const  imin_str = boost::lexical_cast<std::string>(imin);
 111     std::string const  imax_str = boost::lexical_cast<std::string>(imax);
 112     std::string const  lmin_str = boost::lexical_cast<std::string>(lmin);
 113     std::string const  lmax_str = boost::lexical_cast<std::string>(lmax);
 114     std::string const llmin_str = boost::lexical_cast<std::string>(llmin);
 115     std::string const llmax_str = boost::lexical_cast<std::string>(llmax);
 116
 117     BOOST_TEST( imin_str == convert<std::string>( imin).value());
 118     BOOST_TEST( imax_str == convert<std::string>( imax).value());
 119     BOOST_TEST( lmin_str == convert<std::string>( lmin).value());
 120     BOOST_TEST( lmax_str == convert<std::string>( lmax).value());
 121     BOOST_TEST(llmin_str == convert<std::string>(llmin).value());
 122     BOOST_TEST(llmax_str == convert<std::string>(llmax).value());
 123 }
 124
 125 static
 126 void
 127 test_uint_to_str()
 128 {
 129     unsigned short const      us_int = 123;
 130     unsigned int const        ui_int = 123;
 131     unsigned long const       ul_int = 123;
 132     unsigned long long const ull_int = 123;
 133
 134     BOOST_TEST( "123" == convert< std::string> ( us_int).value());
 135     BOOST_TEST( "123" == convert< std::string> ( ui_int).value());
 136     BOOST_TEST( "123" == convert< std::string> ( ul_int).value());
 137     BOOST_TEST( "123" == convert< std::string> (ull_int).value());
 138
 139     BOOST_TEST(L"123" == convert<std::wstring> ( us_int).value());
 140     BOOST_TEST(L"123" == convert<std::wstring> ( ui_int).value());
 141     BOOST_TEST(L"123" == convert<std::wstring> ( ul_int).value());
 142     BOOST_TEST(L"123" == convert<std::wstring> (ull_int).value());
 143
 144     unsigned int const            uimax = (std::numeric_limits<unsigned int>::max)();
 145     unsigned long int const       ulmax = (std::numeric_limits<unsigned long int>::max)();
 146     unsigned long long int const ullmax = (std::numeric_limits<unsigned long long int>::max)();
 147
 148     std::string const  uimax_str = boost::lexical_cast<std::string>( uimax);
 149     std::string const  ulmax_str = boost::lexical_cast<std::string>( ulmax);
 150     std::string const ullmax_str = boost::lexical_cast<std::string>(ullmax);
 151
 152     BOOST_TEST( uimax_str == convert<std::string>( uimax).value());
 153     BOOST_TEST( ulmax_str == convert<std::string>( ulmax).value());
 154     BOOST_TEST(ullmax_str == convert<std::string>(ullmax).value());
 155 }
 156
 157 //[strtol_numeric_base_header
 158 #include <boost/convert.hpp>
 159 #include <boost/convert/strtol.hpp>
 160
 161 using std::string;
 162 using std::wstring;
 163 using boost::convert;
 164
 165 namespace cnv = boost::cnv;
 166 namespace arg = boost::cnv::parameter;
 167 //]
 168 static
 169 void
 170 test_width()
 171 {
 172     //[strtol_width
 173     boost::cnv::strtol cnv;
 174
 175     string s01 = convert<string>( 12, cnv(arg::width = 4)).value();
 176     string s02 = convert<string>( 12, cnv(arg::width = 5)
 177                                          (arg::fill = '*')).value();
 178     string s03 = convert<string>( 12, cnv(arg::width = 5)
 179                                          (arg::fill = 'x')
 180                                          (arg::adjust = cnv::adjust::left)).value();
 181     string s04 = convert<string>(-98, cnv(arg::width = 6)
 182                                          (arg::fill = 'Z')
 183                                          (arg::adjust = cnv::adjust::right)).value();
 184
 185     string s05 = convert<string>(-12.3451, cnv(arg::precision = 2)
 186                                               (arg::width = 10)
 187                                               (arg::fill = '*')
 188                                               (arg::adjust = cnv::adjust::left)).value();
 189     string s06 = convert<string>(-12.3450, cnv(arg::adjust = cnv::adjust::right)).value();
 190     string s07 = convert<string>(-12.3450, cnv(arg::adjust = cnv::adjust::center)).value();
 191
 192     BOOST_TEST(s01 == "  12");
 193     BOOST_TEST(s02 == "***12");
 194     BOOST_TEST(s03 == "12xxx");
 195     BOOST_TEST(s04 == "ZZZ-98");
 196     BOOST_TEST(s05 == "-12.35****");
 197     BOOST_TEST(s06 == "****-12.35");
 198     BOOST_TEST(s07 == "**-12.35**");
 199     //]
 200 }
 201
 202 static
 203 void
 204 test_base()
 205 {
 206     //[strtol_numeric_base
 207     boost::cnv::strtol cnv;
 208
 209     BOOST_TEST( "11111110" == convert< string>(254, cnv(arg::base = cnv::base::bin)).value());
 210     BOOST_TEST(      "254" == convert< string>(254, cnv(arg::base = cnv::base::dec)).value());
 211     BOOST_TEST(       "FE" == convert< string>(254, cnv(arg::base = cnv::base::hex)).value());
 212     BOOST_TEST(      "376" == convert< string>(254, cnv(arg::base = cnv::base::oct)).value());
 213     //]
 214     //[wide_strtol_numeric_base
 215     BOOST_TEST(L"11111110" == convert<wstring>(254, cnv(arg::base = cnv::base::bin)).value());
 216     BOOST_TEST(     L"254" == convert<wstring>(254, cnv(arg::base = cnv::base::dec)).value());
 217     BOOST_TEST(      L"FE" == convert<wstring>(254, cnv(arg::base = cnv::base::hex)).value());
 218     BOOST_TEST(     L"376" == convert<wstring>(254, cnv(arg::base = cnv::base::oct)).value());
 219     //]
 220 }
 221
 222 static
 223 void
 224 test_upper()
 225 {
 226 //    boost::cnv::strtol cnv;
 227 //    char const*    c_lcase =  "abcde";
 228 //    char const*    c_ucase =  "ABCDE";
 229 //    wchar_t const* w_lcase = L"abcde";
 230 //    wchar_t const* w_ucase = L"ABCDE";
 231 //
 232 //    BOOST_TEST(c_lcase == convert< string>(c_lcase, cnv(arg::uppercase = false)).value_or(""));
 233 //    BOOST_TEST(c_ucase == convert< string>(c_lcase, cnv(arg::uppercase =  true)).value_or(""));
 234 //    BOOST_TEST(w_ucase == convert<wstring>(w_lcase, cnv(arg::uppercase = false)).value_or(""));
 235 //    BOOST_TEST(w_ucase == convert<wstring>(w_lcase, cnv(arg::uppercase =  true)).value_or(""));
 236 }
 237
 238 static
 239 void
 240 test_skipws()
 241 {
 242     //[strtol_skipws
 243     boost::cnv::strtol cnv;
 244
 245     BOOST_TEST(-1 == convert<int>( " 12", cnv(arg::skipws = false)).value_or(-1));
 246     BOOST_TEST(12 == convert<int>( " 12", cnv(arg::skipws =  true)).value_or(-1));
 247     //]
 248     //[wide_strtol_skipws
 249     BOOST_TEST(-1 == convert<int>(L" 12", cnv(arg::skipws = false)).value_or(-1));
 250     BOOST_TEST(12 == convert<int>(L" 12", cnv(arg::skipws =  true)).value_or(-1));
 251     //]
 252 }
 253
 254 static
 255 void
 256 dbl_to_str_example()
 257 {
 258     //[strtol_precision
 259     boost::cnv::strtol cnv;
 260
 261     BOOST_TEST(  "12.3" == convert<string>(12.3456, cnv(arg::precision = 1)).value());
 262     BOOST_TEST( "12.35" == convert<string>(12.3456, cnv(arg::precision = 2)).value());
 263     BOOST_TEST("12.346" == convert<string>(12.3456, cnv(arg::precision = 3)).value());
 264
 265     BOOST_TEST(  "-12.3" == convert<string>(-12.3456, cnv(arg::precision = 1)).value());
 266     BOOST_TEST( "-12.35" == convert<string>(-12.3456, cnv(arg::precision = 2)).value());
 267     BOOST_TEST("-12.346" == convert<string>(-12.3456, cnv(arg::precision = 3)).value());
 268     //]
 269 }
 270
 271 static
 272 std::pair<double, int>
 273 get_random()
 274 {
 275     namespace rdm = boost::random;
 276
 277     static rdm::mt19937                          gen (::time(0));
 278     static rdm::uniform_int_distribution<> precision (0, 6);
 279     static rdm::uniform_int_distribution<>  int_part (0, SHRT_MAX);
 280     static rdm::uniform_01<double>          fraction; // uniform double in [0,1)
 281     static bool                                 sign;
 282
 283     double dbl = (int_part(gen) + fraction(gen)) * ((sign = !sign) ? 1 : -1);
 284
 285 //  printf("%.12f\n", dbl);
 286
 287     return std::make_pair(dbl, precision(gen));
 288 }
 289
 290 static
 291 void
 292 compare(std::pair<double, int> pair)
 293 {
 294     boost::cnv::strtol cnv1;
 295     boost::cnv::printf cnv2;
 296
 297     string s1 = convert<string>(pair.first, cnv1(arg::precision = pair.second)).value();
 298     string s2 = convert<string>(pair.first, cnv2(arg::precision = pair.second)).value();
 299
 300     if (s1 != s2)
 301         printf("dbl=%.12f(%d).strtol/printf=%s/%s.\n", pair.first, pair.second, s1.c_str(), s2.c_str());
 302 }
 303
 304 static
 305 void
 306 test_str_to_dbl()
 307 {
 308     char const* const c_str = "1.23456";
 309
 310     BOOST_TEST(1.2  == convert<double>(boost::string_view(c_str, 3)).value_or(0));
 311     BOOST_TEST(1.23 == convert<double>(boost::string_view(c_str, 4)).value_or(0));
 312 }
 313
 314 static
 315 void
 316 test_dbl_to_str()
 317 {
 318 //    double      round_up_abs01 = ::rint(-0.5);
 319 //    double      round_up_abs02 = ::round(-0.5);
 320 //    double      round_up_abs11 = ::rint(0.5);
 321 //    double      round_up_abs12 = ::round(0.5);
 322
 323 //    double huge_v = 987654321098765432109.123;
 324 //
 325 //    printf("%f\n", huge_v);
 326 //    string huge = convert<string>(huge_v, cnv1(arg::precision = 2)).value();
 327 //    printf("%s\n", huge.c_str());
 328
 329     int const num_tries = 1000000;
 330     double const dbls[] = { 0.90, 1.0, 1.1, 0.94, 0.96, 1.04, 1.05, 1.06, 9.654, 999.888 };
 331     int const  num_dbls = sizeof(dbls) / sizeof(dbls[0]);
 332
 333     printf("cnv::strtol::%s: started with %d random numbers...\n", __FUNCTION__, num_tries);
 334
 335     BOOST_TEST(   "0" == convert<string>( 0.0, cnv::strtol()(arg::precision = 0)).value());
 336     BOOST_TEST( "0.0" == convert<string>( 0.0, cnv::strtol()(arg::precision = 1)).value());
 337     BOOST_TEST("0.00" == convert<string>( 0.0, cnv::strtol()(arg::precision = 2)).value());
 338     BOOST_TEST(   "1" == convert<string>(0.95, cnv::strtol()(arg::precision = 0)).value());
 339     BOOST_TEST( "1.0" == convert<string>(0.95, cnv::strtol()(arg::precision = 1)).value());
 340     BOOST_TEST("0.95" == convert<string>(0.95, cnv::strtol()(arg::precision = 2)).value());
 341
 342     for (int k = 0; k < num_tries; ++k)
 343         compare(get_random());
 344
 345     for (int k = 0; k < num_dbls; ++k)
 346         for (int precision = 0; precision < 3; ++precision)
 347         {
 348             compare(std::make_pair( dbls[k], precision));
 349             compare(std::make_pair(-dbls[k], precision));
 350         }
 351
 352     printf("cnv::strtol::%s: finished.\n", __FUNCTION__);
 353 }
 354
 355 static
 356 void
 357 test_user_string()
 358 {
 359     //[strtol_user_string
 360     boost::cnv::strtol cnv;
 361
 362     BOOST_TEST(  "12" == convert<my_string>(12, cnv).value());
 363     BOOST_TEST("0.95" == convert<my_string>(0.95, cnv(arg::precision = 2)).value());
 364     //]
 365 }
 366
 367 static
 368 void
 369 test_user_type()
 370 {
 371     //[strtol_user_type
 372     boost::cnv::strtol cnv;
 373     change          up_chg = change::up;
 374     change          dn_chg = change::dn;
 375
 376     BOOST_TEST(convert<std::string>(up_chg, cnv, "bad") == "up");
 377     BOOST_TEST(convert<std::string>(dn_chg, cnv, "bad") == "dn");
 378     BOOST_TEST(convert<std::string>(    12, cnv, "bad") == "12");
 379
 380     BOOST_TEST(convert<change>("up", cnv, change::no) == change::up);
 381     BOOST_TEST(convert<change>("dn", cnv, change::no) == change::dn);
 382     BOOST_TEST(convert<   int>("12", cnv, -1) == 12);
 383     //]
 384 }
 385
 386 int
 387 main(int, char const* [])
 388 {
 389     dbl_to_str_example();
 390
 391     test_str_to_int();
 392     test_str_to_uint();
 393     test_int_to_str();
 394     test_uint_to_str();
 395     test_base();
 396     test_upper();
 397     test_skipws();
 398     test_str_to_dbl();
 399     test_dbl_to_str();
 400     test_width();
 401     test_user_string();
 402     test_user_type();
 403
 404     return boost::report_errors();
 405 }
 406
 407 #endif