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