folly/test/ConvTest.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __STDC_FORMAT_MACROS
  18 #define __STDC_FORMAT_MACROS 1
  19 #endif
  20
  21 #include <boost/lexical_cast.hpp>
  22
  23 #include <folly/Conv.h>
  24 #include <folly/Foreach.h>
  25 #include <folly/portability/GTest.h>
  26
  27 #include <algorithm>
  28 #include <cinttypes>
  29 #include <limits>
  30 #include <sstream>
  31 #include <stdexcept>
  32 #include <tuple>
  33
  34 using namespace std;
  35 using namespace folly;
  36
  37
  38 TEST(Conv, digits10) {
  39   char buffer[100];
  40   uint64_t power;
  41
  42   // first, some basic sniff tests
  43   EXPECT_EQ( 1, digits10(0));
  44   EXPECT_EQ( 1, digits10(1));
  45   EXPECT_EQ( 1, digits10(9));
  46   EXPECT_EQ( 2, digits10(10));
  47   EXPECT_EQ( 2, digits10(99));
  48   EXPECT_EQ( 3, digits10(100));
  49   EXPECT_EQ( 3, digits10(999));
  50   EXPECT_EQ( 4, digits10(1000));
  51   EXPECT_EQ( 4, digits10(9999));
  52   EXPECT_EQ(20, digits10(18446744073709551615ULL));
  53
  54   // try the first X nonnegatives.
  55   // Covers some more cases of 2^p, 10^p
  56   for (uint64_t i = 0; i < 100000; i++) {
  57     snprintf(buffer, sizeof(buffer), "%" PRIu64, i);
  58     EXPECT_EQ(strlen(buffer), digits10(i));
  59   }
  60
  61   // try powers of 2
  62   power = 1;
  63   for (int p = 0; p < 64; p++) {
  64     snprintf(buffer, sizeof(buffer), "%" PRIu64, power);
  65     EXPECT_EQ(strlen(buffer), digits10(power));
  66     snprintf(buffer, sizeof(buffer), "%" PRIu64, power - 1);
  67     EXPECT_EQ(strlen(buffer), digits10(power - 1));
  68     snprintf(buffer, sizeof(buffer), "%" PRIu64, power + 1);
  69     EXPECT_EQ(strlen(buffer), digits10(power + 1));
  70     power *= 2;
  71   }
  72
  73   // try powers of 10
  74   power = 1;
  75   for (int p = 0; p < 20; p++) {
  76     snprintf(buffer, sizeof(buffer), "%" PRIu64, power);
  77     EXPECT_EQ(strlen(buffer), digits10(power));
  78     snprintf(buffer, sizeof(buffer), "%" PRIu64, power - 1);
  79     EXPECT_EQ(strlen(buffer), digits10(power - 1));
  80     snprintf(buffer, sizeof(buffer), "%" PRIu64, power + 1);
  81     EXPECT_EQ(strlen(buffer), digits10(power + 1));
  82     power *= 10;
  83   }
  84 }
  85
  86 // Test to<T>(T)
  87 TEST(Conv, Type2Type) {
  88   bool boolV = true;
  89   EXPECT_EQ(to<bool>(boolV), true);
  90
  91   int intV = 42;
  92   EXPECT_EQ(to<int>(intV), 42);
  93
  94   float floatV = 4.2f;
  95   EXPECT_EQ(to<float>(floatV), 4.2f);
  96
  97   double doubleV = 0.42;
  98   EXPECT_EQ(to<double>(doubleV), 0.42);
  99
 100   std::string stringV = "StdString";
 101   EXPECT_EQ(to<std::string>(stringV), "StdString");
 102
 103   folly::fbstring fbStrV = "FBString";
 104   EXPECT_EQ(to<folly::fbstring>(fbStrV), "FBString");
 105
 106   folly::StringPiece spV("StringPiece");
 107   EXPECT_EQ(to<folly::StringPiece>(spV), "StringPiece");
 108
 109   // Rvalues
 110   EXPECT_EQ(to<bool>(true), true);
 111   EXPECT_EQ(to<int>(42), 42);
 112   EXPECT_EQ(to<float>(4.2f), 4.2f);
 113   EXPECT_EQ(to<double>(.42), .42);
 114   EXPECT_EQ(to<std::string>(std::string("Hello")), "Hello");
 115   EXPECT_EQ(to<folly::fbstring>(folly::fbstring("hello")), "hello");
 116   EXPECT_EQ(to<folly::StringPiece>(folly::StringPiece("Forty Two")),
 117             "Forty Two");
 118 }
 119
 120 TEST(Conv, Integral2Integral) {
 121   // Same size, different signs
 122   int64_t s64 = numeric_limits<uint8_t>::max();
 123   EXPECT_EQ(to<uint8_t>(s64), s64);
 124
 125   s64 = numeric_limits<int8_t>::max();
 126   EXPECT_EQ(to<int8_t>(s64), s64);
 127 }
 128
 129 TEST(Conv, Floating2Floating) {
 130   float f1 = 1e3f;
 131   double d1 = to<double>(f1);
 132   EXPECT_EQ(f1, d1);
 133
 134   double d2 = 23.0;
 135   auto f2 = to<float>(d2);
 136   EXPECT_EQ(double(f2), d2);
 137
 138   double invalidFloat = std::numeric_limits<double>::max();
 139   EXPECT_ANY_THROW(to<float>(invalidFloat));
 140   invalidFloat = -std::numeric_limits<double>::max();
 141   EXPECT_ANY_THROW(to<float>(invalidFloat));
 142
 143   try {
 144     auto shouldWork = to<float>(std::numeric_limits<double>::min());
 145     // The value of `shouldWork' is an implementation defined choice
 146     // between the following two alternatives.
 147     EXPECT_TRUE(shouldWork == std::numeric_limits<float>::min() ||
 148                 shouldWork == 0.f);
 149   } catch (...) {
 150     ADD_FAILURE();
 151   }
 152 }
 153
 154 template <class String>
 155 void testIntegral2String() {
 156 }
 157
 158 template <class String, class Int, class... Ints>
 159 void testIntegral2String() {
 160   typedef typename make_unsigned<Int>::type Uint;
 161   typedef typename make_signed<Int>::type Sint;
 162
 163   Uint value = 123;
 164   EXPECT_EQ(to<String>(value), "123");
 165   Sint svalue = 123;
 166   EXPECT_EQ(to<String>(svalue), "123");
 167   svalue = -123;
 168   EXPECT_EQ(to<String>(svalue), "-123");
 169
 170   value = numeric_limits<Uint>::min();
 171   EXPECT_EQ(to<Uint>(to<String>(value)), value);
 172   value = numeric_limits<Uint>::max();
 173   EXPECT_EQ(to<Uint>(to<String>(value)), value);
 174
 175   svalue = numeric_limits<Sint>::min();
 176   EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
 177   value = numeric_limits<Sint>::max();
 178   EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
 179
 180   testIntegral2String<String, Ints...>();
 181 }
 182
 183 #if FOLLY_HAVE_INT128_T
 184 template <class String>
 185 void test128Bit2String() {
 186   typedef unsigned __int128 Uint;
 187   typedef __int128 Sint;
 188
 189   EXPECT_EQ(detail::digitsEnough<unsigned __int128>(), 39);
 190
 191   Uint value = 123;
 192   EXPECT_EQ(to<String>(value), "123");
 193   Sint svalue = 123;
 194   EXPECT_EQ(to<String>(svalue), "123");
 195   svalue = -123;
 196   EXPECT_EQ(to<String>(svalue), "-123");
 197
 198   value = __int128(1) << 64;
 199   EXPECT_EQ(to<String>(value), "18446744073709551616");
 200
 201   svalue =  -(__int128(1) << 64);
 202   EXPECT_EQ(to<String>(svalue), "-18446744073709551616");
 203
 204   value = 0;
 205   EXPECT_EQ(to<String>(value), "0");
 206
 207   svalue = 0;
 208   EXPECT_EQ(to<String>(svalue), "0");
 209
 210   value = ~__int128(0);
 211   EXPECT_EQ(to<String>(value), "340282366920938463463374607431768211455");
 212
 213   svalue = -(Uint(1) << 127);
 214   EXPECT_EQ(to<String>(svalue), "-170141183460469231731687303715884105728");
 215
 216   svalue = (Uint(1) << 127) - 1;
 217   EXPECT_EQ(to<String>(svalue), "170141183460469231731687303715884105727");
 218
 219   // TODO: the following do not compile to<__int128> ...
 220
 221 #if 0
 222   value = numeric_limits<Uint>::min();
 223   EXPECT_EQ(to<Uint>(to<String>(value)), value);
 224   value = numeric_limits<Uint>::max();
 225   EXPECT_EQ(to<Uint>(to<String>(value)), value);
 226
 227   svalue = numeric_limits<Sint>::min();
 228   EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
 229   value = numeric_limits<Sint>::max();
 230   EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
 231 #endif
 232 }
 233
 234 #endif
 235
 236 TEST(Conv, Integral2String) {
 237   testIntegral2String<std::string, int8_t, int16_t, int32_t, int64_t>();
 238   testIntegral2String<fbstring, int8_t, int16_t, int32_t, int64_t>();
 239
 240 #if FOLLY_HAVE_INT128_T
 241   test128Bit2String<std::string>();
 242   test128Bit2String<fbstring>();
 243 #endif
 244 }
 245
 246 template <class String>
 247 void testString2Integral() {
 248 }
 249
 250 template <class String, class Int, class... Ints>
 251 void testString2Integral() {
 252   typedef typename make_unsigned<Int>::type Uint;
 253   typedef typename make_signed<Int>::type Sint;
 254
 255   // Unsigned numbers small enough to fit in a signed type
 256   static const String strings[] = {
 257     "0",
 258     "00",
 259     "2 ",
 260     " 84",
 261     " \n 123    \t\n",
 262     " 127",
 263     "0000000000000000000000000042"
 264   };
 265   static const Uint values[] = {
 266     0,
 267     0,
 268     2,
 269     84,
 270     123,
 271     127,
 272     42
 273   };
 274   FOR_EACH_RANGE (i, 0, sizeof(strings) / sizeof(*strings)) {
 275     EXPECT_EQ(to<Uint>(strings[i]), values[i]);
 276     EXPECT_EQ(to<Sint>(strings[i]), values[i]);
 277   }
 278
 279   // Unsigned numbers that won't fit in the signed variation
 280   static const String uStrings[] = {
 281     " 128",
 282     "213",
 283     "255"
 284   };
 285   static const Uint uValues[] = {
 286     128,
 287     213,
 288     255
 289   };
 290   FOR_EACH_RANGE (i, 0, sizeof(uStrings)/sizeof(*uStrings)) {
 291     EXPECT_EQ(to<Uint>(uStrings[i]), uValues[i]);
 292     if (sizeof(Int) == 1) {
 293       EXPECT_THROW(to<Sint>(uStrings[i]), std::range_error);
 294     }
 295   }
 296
 297   if (sizeof(Int) >= 4) {
 298     static const String strings2[] = {
 299       "256",
 300       "6324 ",
 301       "63245675 ",
 302       "2147483647"
 303     };
 304     static const Uint values2[] = {
 305       (Uint)256,
 306       (Uint)6324,
 307       (Uint)63245675,
 308       (Uint)2147483647
 309     };
 310     FOR_EACH_RANGE (i, 0, sizeof(strings2)/sizeof(*strings2)) {
 311       EXPECT_EQ(to<Uint>(strings2[i]), values2[i]);
 312       EXPECT_EQ(to<Sint>(strings2[i]), values2[i]);
 313     }
 314
 315     static const String uStrings2[] = {
 316       "2147483648",
 317       "3147483648",
 318       "4147483648",
 319       "4000000000",
 320     };
 321     static const Uint uValues2[] = {
 322       (Uint)2147483648U,
 323       (Uint)3147483648U,
 324       (Uint)4147483648U,
 325       (Uint)4000000000U,
 326     };
 327     FOR_EACH_RANGE (i, 0, sizeof(uStrings2)/sizeof(uStrings2)) {
 328       EXPECT_EQ(to<Uint>(uStrings2[i]), uValues2[i]);
 329       if (sizeof(Int) == 4) {
 330         EXPECT_THROW(to<Sint>(uStrings2[i]), std::range_error);
 331       }
 332     }
 333   }
 334
 335   if (sizeof(Int) >= 8) {
 336     static_assert(sizeof(Int) <= 8, "Now that would be interesting");
 337     static const String strings3[] = {
 338       "2147483648",
 339       "5000000001",
 340       "25687346509278435",
 341       "100000000000000000",
 342       "9223372036854775807",
 343     };
 344     static const Uint values3[] = {
 345       (Uint)2147483648ULL,
 346       (Uint)5000000001ULL,
 347       (Uint)25687346509278435ULL,
 348       (Uint)100000000000000000ULL,
 349       (Uint)9223372036854775807ULL,
 350     };
 351     FOR_EACH_RANGE (i, 0, sizeof(strings3)/sizeof(*strings3)) {
 352       EXPECT_EQ(to<Uint>(strings3[i]), values3[i]);
 353       EXPECT_EQ(to<Sint>(strings3[i]), values3[i]);
 354     }
 355
 356     static const String uStrings3[] = {
 357       "9223372036854775808",
 358       "9987435987394857987",
 359       "17873648761234698740",
 360       "18446744073709551615",
 361     };
 362     static const Uint uValues3[] = {
 363       (Uint)9223372036854775808ULL,
 364       (Uint)9987435987394857987ULL,
 365       (Uint)17873648761234698740ULL,
 366       (Uint)18446744073709551615ULL,
 367     };
 368     FOR_EACH_RANGE (i, 0, sizeof(uStrings3)/sizeof(*uStrings3)) {
 369       EXPECT_EQ(to<Uint>(uStrings3[i]), uValues3[i]);
 370       if (sizeof(Int) == 8) {
 371         EXPECT_THROW(to<Sint>(uStrings3[i]), std::range_error);
 372       }
 373     }
 374   }
 375
 376   // Minimum possible negative values, and negative sign overflow
 377   static const String strings4[] = {
 378     "-128",
 379     "-32768",
 380     "-2147483648",
 381     "-9223372036854775808",
 382   };
 383   static const String strings5[] = {
 384     "-129",
 385     "-32769",
 386     "-2147483649",
 387     "-9223372036854775809",
 388   };
 389   static const Sint values4[] = {
 390     (Sint)-128LL,
 391     (Sint)-32768LL,
 392     (Sint)-2147483648LL,
 393     (Sint)(-9223372036854775807LL - 1),
 394   };
 395   FOR_EACH_RANGE (i, 0, sizeof(strings4)/sizeof(*strings4)) {
 396     if (sizeof(Int) > std::pow(2, i)) {
 397       EXPECT_EQ(values4[i], to<Sint>(strings4[i]));
 398       EXPECT_EQ(values4[i] - 1, to<Sint>(strings5[i]));
 399     } else if (sizeof(Int) == std::pow(2, i)) {
 400       EXPECT_EQ(values4[i], to<Sint>(strings4[i]));
 401       EXPECT_THROW(to<Sint>(strings5[i]), std::range_error);
 402     } else {
 403       EXPECT_THROW(to<Sint>(strings4[i]), std::range_error);
 404       EXPECT_THROW(to<Sint>(strings5[i]), std::range_error);
 405     }
 406   }
 407
 408   // Bogus string values
 409   static const String bogusStrings[] = {
 410     "",
 411     "0x1234",
 412     "123L",
 413     "123a",
 414     "x 123 ",
 415     "234 y",
 416     "- 42",  // whitespace is not allowed between the sign and the value
 417     " +   13 ",
 418     "12345678901234567890123456789",
 419   };
 420   for (const auto& str : bogusStrings) {
 421     EXPECT_THROW(to<Sint>(str), std::range_error);
 422     EXPECT_THROW(to<Uint>(str), std::range_error);
 423   }
 424
 425   // A leading '+' character is only allowed when converting to signed types.
 426   String posSign("+42");
 427   EXPECT_EQ(42, to<Sint>(posSign));
 428   EXPECT_THROW(to<Uint>(posSign), std::range_error);
 429
 430   testString2Integral<String, Ints...>();
 431 }
 432
 433 TEST(Conv, String2Integral) {
 434   testString2Integral<const char*, int8_t, int16_t, int32_t, int64_t>();
 435   testString2Integral<std::string, int8_t, int16_t, int32_t, int64_t>();
 436   testString2Integral<fbstring, int8_t, int16_t, int32_t, int64_t>();
 437
 438   // Testing the behavior of the StringPiece* API
 439   // StringPiece* normally parses as much valid data as it can,
 440   // and advances the StringPiece to the end of the valid data.
 441   char buf1[] = "100foo";
 442   StringPiece sp1(buf1);
 443   EXPECT_EQ(100, to<uint8_t>(&sp1));
 444   EXPECT_EQ(buf1 + 3, sp1.begin());
 445   // However, if the next character would cause an overflow it throws a
 446   // range_error rather than consuming only as much as it can without
 447   // overflowing.
 448   char buf2[] = "1002";
 449   StringPiece sp2(buf2);
 450   EXPECT_THROW(to<uint8_t>(&sp2), std::range_error);
 451   EXPECT_EQ(buf2, sp2.begin());
 452 }
 453
 454 TEST(Conv, StringPiece2Integral) {
 455   string s = "  +123  hello world  ";
 456   StringPiece sp = s;
 457   EXPECT_EQ(to<int>(&sp), 123);
 458   EXPECT_EQ(sp, "  hello world  ");
 459 }
 460
 461 TEST(Conv, StringPieceAppend) {
 462   string s = "foobar";
 463   {
 464     StringPiece sp(s, 0, 3);
 465     string result = to<string>(s, sp);
 466     EXPECT_EQ(result, "foobarfoo");
 467   }
 468   {
 469     StringPiece sp1(s, 0, 3);
 470     StringPiece sp2(s, 3, 3);
 471     string result = to<string>(sp1, sp2);
 472     EXPECT_EQ(result, s);
 473   }
 474 }
 475
 476 TEST(Conv, BadStringToIntegral) {
 477   // Note that leading spaces (e.g.  " 1") are valid.
 478   vector<string> v = { "a", "", " ", "\n", " a0", "abcdef", "1Z", "!#" };
 479   for (auto& s: v) {
 480     EXPECT_THROW(to<int>(s), std::range_error) << "s=" << s;
 481   }
 482 }
 483
 484 template <class String>
 485 void testIdenticalTo() {
 486   String s("Yukkuri shiteitte ne!!!");
 487
 488   String result = to<String>(s);
 489   EXPECT_EQ(result, s);
 490 }
 491
 492 template <class String>
 493 void testVariadicTo() {
 494   String s;
 495   toAppend(&s);
 496   toAppend("Lorem ipsum ", 1234, String(" dolor amet "), 567.89, '!', &s);
 497   EXPECT_EQ(s, "Lorem ipsum 1234 dolor amet 567.89!");
 498
 499   s = to<String>();
 500   EXPECT_TRUE(s.empty());
 501
 502   s = to<String>("Lorem ipsum ", nullptr, 1234, " dolor amet ", 567.89, '.');
 503   EXPECT_EQ(s, "Lorem ipsum 1234 dolor amet 567.89.");
 504 }
 505
 506 template <class String>
 507 void testIdenticalToDelim() {
 508   String s("Yukkuri shiteitte ne!!!");
 509
 510   String charDelim = toDelim<String>('$', s);
 511   EXPECT_EQ(charDelim, s);
 512
 513   String strDelim = toDelim<String>(String(">_<"), s);
 514   EXPECT_EQ(strDelim, s);
 515 }
 516
 517 template <class String>
 518 void testVariadicToDelim() {
 519   String s;
 520   toAppendDelim(":", &s);
 521   toAppendDelim(
 522       ":", "Lorem ipsum ", 1234, String(" dolor amet "), 567.89, '!', &s);
 523   EXPECT_EQ(s, "Lorem ipsum :1234: dolor amet :567.89:!");
 524
 525   s = toDelim<String>(':');
 526   EXPECT_TRUE(s.empty());
 527
 528   s = toDelim<String>(
 529       ":", "Lorem ipsum ", nullptr, 1234, " dolor amet ", 567.89, '.');
 530   EXPECT_EQ(s, "Lorem ipsum ::1234: dolor amet :567.89:.");
 531 }
 532
 533 TEST(Conv, NullString) {
 534   string s1 = to<string>((char *) nullptr);
 535   EXPECT_TRUE(s1.empty());
 536   fbstring s2 = to<fbstring>((char *) nullptr);
 537   EXPECT_TRUE(s2.empty());
 538 }
 539
 540 TEST(Conv, VariadicTo) {
 541   testIdenticalTo<string>();
 542   testIdenticalTo<fbstring>();
 543   testVariadicTo<string>();
 544   testVariadicTo<fbstring>();
 545 }
 546
 547 TEST(Conv, VariadicToDelim) {
 548   testIdenticalToDelim<string>();
 549   testIdenticalToDelim<fbstring>();
 550   testVariadicToDelim<string>();
 551   testVariadicToDelim<fbstring>();
 552 }
 553
 554 template <class String>
 555 void testDoubleToString() {
 556   EXPECT_EQ(to<string>(0.0), "0");
 557   EXPECT_EQ(to<string>(0.5), "0.5");
 558   EXPECT_EQ(to<string>(10.25), "10.25");
 559   EXPECT_EQ(to<string>(1.123e10), "11230000000");
 560 }
 561
 562 TEST(Conv, DoubleToString) {
 563   testDoubleToString<string>();
 564   testDoubleToString<fbstring>();
 565 }
 566
 567 TEST(Conv, FBStringToString) {
 568   fbstring foo("foo");
 569   string ret = to<string>(foo);
 570   EXPECT_EQ(ret, "foo");
 571   string ret2 = to<string>(foo, 2);
 572   EXPECT_EQ(ret2, "foo2");
 573 }
 574
 575 TEST(Conv, StringPieceToDouble) {
 576   vector<tuple<const char*, const char*, double>> strs{
 577       make_tuple("2134123.125 zorro", " zorro", 2134123.125),
 578       make_tuple("  2134123.125 zorro", " zorro", 2134123.125),
 579       make_tuple(" 2134123.125  zorro", "  zorro", 2134123.125),
 580       make_tuple(" 2134123.125  zorro ", "  zorro ", 2134123.125),
 581       make_tuple("2134123.125zorro", "zorro", 2134123.125),
 582       make_tuple("0 zorro", " zorro", 0.0),
 583       make_tuple("  0 zorro", " zorro", 0.0),
 584       make_tuple(" 0  zorro", "  zorro", 0.0),
 585       make_tuple(" 0  zorro ", "  zorro ", 0.0),
 586       make_tuple("0zorro", "zorro", 0.0),
 587       make_tuple("0.0 zorro", " zorro", 0.0),
 588       make_tuple("  0.0 zorro", " zorro", 0.0),
 589       make_tuple(" 0.0  zorro", "  zorro", 0.0),
 590       make_tuple(" 0.0  zorro ", "  zorro ", 0.0),
 591       make_tuple("0.0zorro", "zorro", 0.0),
 592   };
 593   for (const auto& s : strs) {
 594     StringPiece pc(get<0>(s));
 595     EXPECT_EQ(get<2>(s), to<double>(&pc)) << "\"" << get<0>(s) << "\"";
 596     EXPECT_EQ(get<1>(s), pc);
 597     EXPECT_THROW(to<double>(StringPiece(get<0>(s))), std::range_error);
 598     EXPECT_EQ(get<2>(s), to<double>(StringPiece(get<0>(s), pc.data())));
 599   }
 600
 601   // Test NaN conversion
 602   try {
 603     to<double>("not a number");
 604     ADD_FAILURE();
 605   } catch (const std::range_error &) {
 606   }
 607
 608   EXPECT_TRUE(std::isnan(to<double>("nan")));
 609   EXPECT_TRUE(std::isnan(to<double>("NaN")));
 610   EXPECT_TRUE(std::isnan(to<double>("NAN")));
 611   EXPECT_TRUE(std::isnan(to<double>("-nan")));
 612   EXPECT_TRUE(std::isnan(to<double>("-NaN")));
 613   EXPECT_TRUE(std::isnan(to<double>("-NAN")));
 614
 615   EXPECT_EQ(to<double>("inf"), numeric_limits<double>::infinity());
 616   EXPECT_EQ(to<double>("Inf"), numeric_limits<double>::infinity());
 617   EXPECT_EQ(to<double>("INF"), numeric_limits<double>::infinity());
 618   EXPECT_EQ(to<double>("inF"), numeric_limits<double>::infinity());
 619   EXPECT_EQ(to<double>("infinity"), numeric_limits<double>::infinity());
 620   EXPECT_EQ(to<double>("Infinity"), numeric_limits<double>::infinity());
 621   EXPECT_EQ(to<double>("INFINITY"), numeric_limits<double>::infinity());
 622   EXPECT_EQ(to<double>("iNfInItY"), numeric_limits<double>::infinity());
 623   EXPECT_THROW(to<double>("infinitX"), std::range_error);
 624   EXPECT_EQ(to<double>("-inf"), -numeric_limits<double>::infinity());
 625   EXPECT_EQ(to<double>("-Inf"), -numeric_limits<double>::infinity());
 626   EXPECT_EQ(to<double>("-INF"), -numeric_limits<double>::infinity());
 627   EXPECT_EQ(to<double>("-inF"), -numeric_limits<double>::infinity());
 628   EXPECT_EQ(to<double>("-infinity"), -numeric_limits<double>::infinity());
 629   EXPECT_EQ(to<double>("-Infinity"), -numeric_limits<double>::infinity());
 630   EXPECT_EQ(to<double>("-INFINITY"), -numeric_limits<double>::infinity());
 631   EXPECT_EQ(to<double>("-iNfInItY"), -numeric_limits<double>::infinity());
 632   EXPECT_THROW(to<double>("-infinitX"), std::range_error);
 633 }
 634
 635 TEST(Conv, EmptyStringToInt) {
 636   string s = "";
 637   StringPiece pc(s);
 638
 639   try {
 640     to<int>(pc);
 641     ADD_FAILURE();
 642   } catch (const std::range_error &) {
 643   }
 644 }
 645
 646 TEST(Conv, CorruptedStringToInt) {
 647   string s = "-1";
 648   StringPiece pc(s.data(), s.data() + 1); // Only  "-"
 649
 650   try {
 651     to<int64_t>(&pc);
 652     ADD_FAILURE();
 653   } catch (const std::range_error &) {
 654   }
 655 }
 656
 657 TEST(Conv, EmptyStringToDouble) {
 658   string s = "";
 659   StringPiece pc(s);
 660
 661   try {
 662     to<double>(pc);
 663     ADD_FAILURE();
 664   } catch (const std::range_error &) {
 665   }
 666 }
 667
 668 TEST(Conv, IntToDouble) {
 669   auto d = to<double>(42);
 670   EXPECT_EQ(d, 42);
 671   /* This seems not work in ubuntu11.10, gcc 4.6.1
 672   try {
 673     auto f = to<float>(957837589847);
 674     ADD_FAILURE();
 675   } catch (std::range_error& e) {
 676     //LOG(INFO) << e.what();
 677   }
 678   */
 679 }
 680
 681 TEST(Conv, DoubleToInt) {
 682   auto i = to<int>(42.0);
 683   EXPECT_EQ(i, 42);
 684   try {
 685     auto i2 = to<int>(42.1);
 686     LOG(ERROR) << "to<int> returned " << i2 << " instead of throwing";
 687     ADD_FAILURE();
 688   } catch (std::range_error&) {
 689     //LOG(INFO) << e.what();
 690   }
 691 }
 692
 693 TEST(Conv, EnumToInt) {
 694   enum A { x = 42, y = 420, z = 65 };
 695   auto i = to<int>(x);
 696   EXPECT_EQ(i, 42);
 697   auto j = to<char>(x);
 698   EXPECT_EQ(j, 42);
 699   try {
 700     auto i2 = to<char>(y);
 701     LOG(ERROR) << "to<char> returned "
 702                << static_cast<unsigned int>(i2)
 703                << " instead of throwing";
 704     ADD_FAILURE();
 705   } catch (std::range_error&) {
 706     //LOG(INFO) << e.what();
 707   }
 708 }
 709
 710 TEST(Conv, EnumToString) {
 711   // task 813959
 712   enum A { x = 4, y = 420, z = 65 };
 713   EXPECT_EQ("foo.4", to<string>("foo.", x));
 714   EXPECT_EQ("foo.420", to<string>("foo.", y));
 715   EXPECT_EQ("foo.65", to<string>("foo.", z));
 716 }
 717
 718 TEST(Conv, IntToEnum) {
 719   enum A { x = 42, y = 420 };
 720   auto i = to<A>(42);
 721   EXPECT_EQ(i, x);
 722   auto j = to<A>(100);
 723   EXPECT_EQ(j, 100);
 724   try {
 725     auto i2 = to<A>(5000000000L);
 726     LOG(ERROR) << "to<A> returned "
 727                << static_cast<unsigned int>(i2)
 728                << " instead of throwing";
 729     ADD_FAILURE();
 730   } catch (std::range_error&) {
 731     //LOG(INFO) << e.what();
 732   }
 733 }
 734
 735 TEST(Conv, UnsignedEnum) {
 736   enum E : uint32_t { x = 3000000000U };
 737   auto u = to<uint32_t>(x);
 738   EXPECT_EQ(u, 3000000000U);
 739   auto s = to<string>(x);
 740   EXPECT_EQ("3000000000", s);
 741   auto e = to<E>(3000000000U);
 742   EXPECT_EQ(e, x);
 743   try {
 744     auto i = to<int32_t>(x);
 745     LOG(ERROR) << "to<int32_t> returned " << i << " instead of throwing";
 746     ADD_FAILURE();
 747   } catch (std::range_error&) {
 748   }
 749 }
 750
 751 TEST(Conv, UnsignedEnumClass) {
 752   enum class E : uint32_t { x = 3000000000U };
 753   auto u = to<uint32_t>(E::x);
 754   EXPECT_GT(u, 0);
 755   EXPECT_EQ(u, 3000000000U);
 756   EXPECT_EQ("3000000000", to<string>(E::x));
 757   EXPECT_EQ(E::x, to<E>(3000000000U));
 758   EXPECT_EQ(E::x, to<E>("3000000000"));
 759   E e;
 760   EXPECT_TRUE(parseTo("3000000000", e).hasValue());
 761   EXPECT_EQ(E::x, e);
 762   EXPECT_THROW(to<int32_t>(E::x), std::range_error);
 763 }
 764
 765 // Multi-argument to<string> uses toAppend, a different code path than
 766 // to<string>(enum).
 767 TEST(Conv, EnumClassToString) {
 768   enum class A { x = 4, y = 420, z = 65 };
 769   EXPECT_EQ("foo.4", to<string>("foo.", A::x));
 770   EXPECT_EQ("foo.420", to<string>("foo.", A::y));
 771   EXPECT_EQ("foo.65", to<string>("foo.", A::z));
 772 }
 773
 774 TEST(Conv, IntegralToBool) {
 775   EXPECT_FALSE(to<bool>(0));
 776   EXPECT_FALSE(to<bool>(0ul));
 777
 778   EXPECT_TRUE(to<bool>(1));
 779   EXPECT_TRUE(to<bool>(1ul));
 780
 781   EXPECT_TRUE(to<bool>(-42));
 782   EXPECT_TRUE(to<bool>(42ul));
 783 }
 784
 785 template <typename Src>
 786 void testStr2Bool() {
 787   EXPECT_FALSE(to<bool>(Src("0")));
 788   EXPECT_FALSE(to<bool>(Src("  000  ")));
 789
 790   EXPECT_FALSE(to<bool>(Src("n")));
 791   EXPECT_FALSE(to<bool>(Src("no")));
 792   EXPECT_FALSE(to<bool>(Src("false")));
 793   EXPECT_FALSE(to<bool>(Src("False")));
 794   EXPECT_FALSE(to<bool>(Src("  fAlSe"  )));
 795   EXPECT_FALSE(to<bool>(Src("F")));
 796   EXPECT_FALSE(to<bool>(Src("off")));
 797
 798   EXPECT_TRUE(to<bool>(Src("1")));
 799   EXPECT_TRUE(to<bool>(Src("  001 ")));
 800   EXPECT_TRUE(to<bool>(Src("y")));
 801   EXPECT_TRUE(to<bool>(Src("yes")));
 802   EXPECT_TRUE(to<bool>(Src("\nyEs\t")));
 803   EXPECT_TRUE(to<bool>(Src("true")));
 804   EXPECT_TRUE(to<bool>(Src("True")));
 805   EXPECT_TRUE(to<bool>(Src("T")));
 806   EXPECT_TRUE(to<bool>(Src("on")));
 807
 808   EXPECT_THROW(to<bool>(Src("")), std::range_error);
 809   EXPECT_THROW(to<bool>(Src("2")), std::range_error);
 810   EXPECT_THROW(to<bool>(Src("11")), std::range_error);
 811   EXPECT_THROW(to<bool>(Src("19")), std::range_error);
 812   EXPECT_THROW(to<bool>(Src("o")), std::range_error);
 813   EXPECT_THROW(to<bool>(Src("fal")), std::range_error);
 814   EXPECT_THROW(to<bool>(Src("tru")), std::range_error);
 815   EXPECT_THROW(to<bool>(Src("ye")), std::range_error);
 816   EXPECT_THROW(to<bool>(Src("yes foo")), std::range_error);
 817   EXPECT_THROW(to<bool>(Src("bar no")), std::range_error);
 818   EXPECT_THROW(to<bool>(Src("one")), std::range_error);
 819   EXPECT_THROW(to<bool>(Src("true_")), std::range_error);
 820   EXPECT_THROW(to<bool>(Src("bogus_token_that_is_too_long")),
 821                std::range_error);
 822 }
 823
 824 TEST(Conv, StringToBool) {
 825   // testStr2Bool<const char *>();
 826   testStr2Bool<std::string>();
 827
 828   // Test with strings that are not NUL terminated.
 829   const char buf[] = "01234";
 830   EXPECT_FALSE(to<bool>(StringPiece(buf, buf + 1)));  // "0"
 831   EXPECT_TRUE(to<bool>(StringPiece(buf + 1, buf + 2)));  // "1"
 832   const char buf2[] = "one two three";
 833   EXPECT_TRUE(to<bool>(StringPiece(buf2, buf2 + 2)));  // "on"
 834   const char buf3[] = "false";
 835   EXPECT_THROW(to<bool>(StringPiece(buf3, buf3 + 3)),  // "fal"
 836                std::range_error);
 837
 838   // Test the StringPiece* API
 839   const char buf4[] = "001foo";
 840   StringPiece sp4(buf4);
 841   EXPECT_TRUE(to<bool>(&sp4));
 842   EXPECT_EQ(buf4 + 3, sp4.begin());
 843   const char buf5[] = "0012";
 844   StringPiece sp5(buf5);
 845   EXPECT_THROW(to<bool>(&sp5), std::range_error);
 846   EXPECT_EQ(buf5, sp5.begin());
 847 }
 848
 849 TEST(Conv, Transform) {
 850   const std::vector<int64_t> in{1, 2, 3};
 851   std::vector<std::string> out(in.size());
 852   std::transform(in.begin(), in.end(), out.begin(), to<std::string, int64_t>);
 853   const std::vector<std::string> ref{"1", "2", "3"};
 854   EXPECT_EQ(ref, out);
 855 }
 856
 857 TEST(Conv, FloatToInt) {
 858   EXPECT_EQ(to<int>(42.0f), 42);
 859   EXPECT_EQ(to<int8_t>(-128.0f), int8_t(-128));
 860   EXPECT_THROW(to<int8_t>(-129.0), std::range_error);
 861   EXPECT_THROW(to<int8_t>(127.001), std::range_error);
 862   EXPECT_THROW(to<uint8_t>(-0.0001), std::range_error);
 863   EXPECT_THROW(
 864       to<uint64_t>(static_cast<float>(std::numeric_limits<uint64_t>::max())),
 865       std::range_error);
 866 }
 867
 868 TEST(Conv, IntToFloat) {
 869   EXPECT_EQ(to<float>(42ULL), 42.0);
 870   EXPECT_EQ(to<float>(int8_t(-128)), -128.0);
 871   EXPECT_THROW(
 872       to<float>(std::numeric_limits<uint64_t>::max()), std::range_error);
 873   EXPECT_THROW(
 874       to<float>(std::numeric_limits<int64_t>::max()), std::range_error);
 875   EXPECT_THROW(
 876       to<float>(std::numeric_limits<int64_t>::min() + 1), std::range_error);
 877 #if FOLLY_HAVE_INT128_T
 878   EXPECT_THROW(
 879       to<double>(std::numeric_limits<unsigned __int128>::max()),
 880       std::range_error);
 881   EXPECT_THROW(
 882       to<double>(std::numeric_limits<__int128>::max()), std::range_error);
 883   EXPECT_THROW(
 884       to<double>(std::numeric_limits<__int128>::min() + 1), std::range_error);
 885 #endif
 886 }
 887
 888 TEST(Conv, BoolToFloat) {
 889   EXPECT_EQ(to<double>(true), 1.0);
 890   EXPECT_EQ(to<double>(false), 0.0);
 891 }
 892
 893 TEST(Conv, FloatToBool) {
 894   EXPECT_EQ(to<bool>(1.0), true);
 895   EXPECT_EQ(to<bool>(0.0), false);
 896   EXPECT_EQ(to<bool>(2.7), true);
 897   EXPECT_EQ(to<bool>(std::numeric_limits<double>::max()), true);
 898   EXPECT_EQ(to<bool>(std::numeric_limits<double>::min()), true);
 899   EXPECT_EQ(to<bool>(std::numeric_limits<double>::lowest()), true);
 900   EXPECT_EQ(to<bool>(std::numeric_limits<double>::quiet_NaN()), true);
 901   EXPECT_EQ(to<bool>(std::numeric_limits<double>::infinity()), true);
 902   EXPECT_EQ(to<bool>(-std::numeric_limits<double>::infinity()), true);
 903 }
 904
 905 namespace {
 906
 907 template <typename F>
 908 void testConvError(
 909     F&& expr,
 910     const char* exprStr,
 911     ConversionCode code,
 912     const char* value,
 913     bool quotedValue,
 914     int line) {
 915   std::string where = to<std::string>(__FILE__, "(", line, "): ");
 916   try {
 917     auto res = expr();
 918     ADD_FAILURE() << where << exprStr << " -> " << res;
 919   } catch (const ConversionError& e) {
 920     EXPECT_EQ(code, e.errorCode()) << where << exprStr;
 921     std::string str(e.what());
 922     EXPECT_FALSE(str.empty()) << where << exprStr << " -> " << str;
 923     auto pos = str.find(':');
 924     if (value) {
 925       std::ostringstream exp;
 926       exp << str.substr(0, pos) + ": ";
 927       if (quotedValue) {
 928         exp << "\"" << value << "\"";
 929       } else {
 930         exp << value;
 931       }
 932       EXPECT_EQ(exp.str(), str) << where << exprStr << " -> " << str;
 933     } else {
 934       EXPECT_EQ(pos, std::string::npos) << where << exprStr << " -> " << str;
 935     }
 936   }
 937 }
 938 }
 939
 940 #define EXPECT_CONV_ERROR_QUOTE(expr, code, value, quoted) \
 941   testConvError(                                           \
 942       [&] { return expr; },                                \
 943       #expr,                                               \
 944       ConversionCode::code,                                \
 945       value,                                               \
 946       quoted,                                              \
 947       __LINE__)
 948
 949 #define EXPECT_CONV_ERROR(expr, code, value) \
 950   EXPECT_CONV_ERROR_QUOTE(expr, code, value, true)
 951
 952 #define EXPECT_CONV_ERROR_STR(type, str, code) \
 953   EXPECT_CONV_ERROR(to<type>(str), code, str)
 954
 955 #define EXPECT_CONV_ERROR_STR_NOVAL(type, str, code) \
 956   EXPECT_CONV_ERROR(to<type>(str), code, nullptr)
 957
 958 TEST(Conv, ConversionErrorStrToBool) {
 959   EXPECT_CONV_ERROR_STR_NOVAL(bool, StringPiece(), EMPTY_INPUT_STRING);
 960   EXPECT_CONV_ERROR_STR_NOVAL(bool, "", EMPTY_INPUT_STRING);
 961   EXPECT_CONV_ERROR_STR(bool, "  ", EMPTY_INPUT_STRING);
 962   EXPECT_CONV_ERROR_STR(bool, " 11 ", BOOL_OVERFLOW);
 963   EXPECT_CONV_ERROR_STR(bool, "other ", BOOL_INVALID_VALUE);
 964   EXPECT_CONV_ERROR_STR(bool, " bla", BOOL_INVALID_VALUE);
 965   EXPECT_CONV_ERROR(to<bool>("  offbla"), NON_WHITESPACE_AFTER_END, "bla");
 966 }
 967
 968 TEST(Conv, ConversionErrorStrToFloat) {
 969   EXPECT_CONV_ERROR_STR_NOVAL(float, StringPiece(), EMPTY_INPUT_STRING);
 970   EXPECT_CONV_ERROR_STR_NOVAL(float, "", EMPTY_INPUT_STRING);
 971   EXPECT_CONV_ERROR_STR(float, "  ", EMPTY_INPUT_STRING);
 972   EXPECT_CONV_ERROR_STR(float, "  junk", STRING_TO_FLOAT_ERROR);
 973   EXPECT_CONV_ERROR(to<float>("  1bla"), NON_WHITESPACE_AFTER_END, "bla");
 974 }
 975
 976 TEST(Conv, ConversionErrorStrToInt) {
 977   // empty string handling
 978   EXPECT_CONV_ERROR_STR_NOVAL(int, StringPiece(), EMPTY_INPUT_STRING);
 979   EXPECT_CONV_ERROR_STR_NOVAL(int, "", EMPTY_INPUT_STRING);
 980   EXPECT_CONV_ERROR_STR(int, "  ", EMPTY_INPUT_STRING);
 981
 982   // signed integers
 983   EXPECT_CONV_ERROR_STR(int, "  *", INVALID_LEADING_CHAR);
 984   EXPECT_CONV_ERROR_STR(int, "  +", NO_DIGITS);
 985   EXPECT_CONV_ERROR_STR(int, "  +*", NON_DIGIT_CHAR);
 986   EXPECT_CONV_ERROR_STR(int8_t, "  128", POSITIVE_OVERFLOW);
 987   EXPECT_CONV_ERROR_STR(int8_t, " -129", NEGATIVE_OVERFLOW);
 988   EXPECT_CONV_ERROR_STR(int8_t, " 1000", POSITIVE_OVERFLOW);
 989   EXPECT_CONV_ERROR_STR(int8_t, "-1000", NEGATIVE_OVERFLOW);
 990   EXPECT_CONV_ERROR(to<int>(" -13bla"), NON_WHITESPACE_AFTER_END, "bla");
 991
 992   // unsigned integers
 993   EXPECT_CONV_ERROR_STR(unsigned, "  -", NON_DIGIT_CHAR);
 994   EXPECT_CONV_ERROR_STR(uint8_t, " 256", POSITIVE_OVERFLOW);
 995   EXPECT_CONV_ERROR(to<unsigned>("42bla"), NON_WHITESPACE_AFTER_END, "bla");
 996 }
 997
 998 #define EXPECT_CONV_ERROR_PP_VAL(type, str, code, val)                  \
 999   do {                                                                  \
1000     StringPiece input(str);                                             \
1001     EXPECT_CONV_ERROR(to<type>(input.begin(), input.end()), code, val); \
1002   } while (0)
1003
1004 #define EXPECT_CONV_ERROR_PP(type, str, code) \
1005   EXPECT_CONV_ERROR_PP_VAL(type, str, code, str)
1006
1007 TEST(Conv, ConversionErrorPtrPairToInt) {
1008   // signed integers
1009   EXPECT_CONV_ERROR_PP(int, "", INVALID_LEADING_CHAR);
1010   EXPECT_CONV_ERROR_PP(int, " ", INVALID_LEADING_CHAR);
1011   EXPECT_CONV_ERROR_PP(int, "*", INVALID_LEADING_CHAR);
1012   EXPECT_CONV_ERROR_PP(int, "+", NO_DIGITS);
1013   EXPECT_CONV_ERROR_PP(int8_t, "128", POSITIVE_OVERFLOW);
1014   EXPECT_CONV_ERROR_PP(int8_t, "-129", NEGATIVE_OVERFLOW);
1015   EXPECT_CONV_ERROR_PP(int8_t, "1000", POSITIVE_OVERFLOW);
1016   EXPECT_CONV_ERROR_PP(int8_t, "-1000", NEGATIVE_OVERFLOW);
1017   EXPECT_CONV_ERROR_PP(int, "-junk", NON_DIGIT_CHAR);
1018
1019   // unsigned integers
1020   EXPECT_CONV_ERROR_PP(unsigned, "", NO_DIGITS);
1021   EXPECT_CONV_ERROR_PP(uint8_t, "256", POSITIVE_OVERFLOW);
1022   EXPECT_CONV_ERROR_PP(unsigned, "junk", NON_DIGIT_CHAR);
1023 }
1024
1025 namespace {
1026
1027 template <typename T, typename V>
1028 std::string prefixWithType(V value) {
1029   std::ostringstream oss;
1030 #ifdef FOLLY_HAS_RTTI
1031   oss << "(" << demangle(typeid(T)) << ") ";
1032 #endif
1033   oss << to<std::string>(value);
1034   return oss.str();
1035 }
1036 }
1037
1038 #define EXPECT_CONV_ERROR_ARITH(type, val, code) \
1039   EXPECT_CONV_ERROR_QUOTE(                       \
1040       to<type>(val), code, prefixWithType<type>(val).c_str(), false)
1041
1042 TEST(Conv, ConversionErrorIntToInt) {
1043   EXPECT_CONV_ERROR_ARITH(signed char, 128, ARITH_POSITIVE_OVERFLOW);
1044   EXPECT_CONV_ERROR_ARITH(unsigned char, -1, ARITH_NEGATIVE_OVERFLOW);
1045 }
1046
1047 TEST(Conv, ConversionErrorFloatToFloat) {
1048   EXPECT_CONV_ERROR_ARITH(
1049       float, std::numeric_limits<double>::max(), ARITH_POSITIVE_OVERFLOW);
1050   EXPECT_CONV_ERROR_ARITH(
1051       float, std::numeric_limits<double>::lowest(), ARITH_NEGATIVE_OVERFLOW);
1052 }
1053
1054 TEST(Conv, ConversionErrorIntToFloat) {
1055   EXPECT_CONV_ERROR_ARITH(
1056       float, std::numeric_limits<long long>::max(), ARITH_LOSS_OF_PRECISION);
1057 }
1058
1059 TEST(Conv, ConversionErrorFloatToInt) {
1060   EXPECT_CONV_ERROR_ARITH(int8_t, 65.5, ARITH_LOSS_OF_PRECISION);
1061 }
1062
1063 TEST(Conv, TryStringToBool) {
1064   auto rv1 = folly::tryTo<bool>("xxxx");
1065   EXPECT_FALSE(rv1.hasValue());
1066   auto rv2 = folly::tryTo<bool>("false");
1067   EXPECT_TRUE(rv2.hasValue());
1068   EXPECT_FALSE(rv2.value());
1069   auto rv3 = folly::tryTo<bool>("yes");
1070   EXPECT_TRUE(rv3.hasValue());
1071   EXPECT_TRUE(rv3.value());
1072 }
1073
1074 TEST(Conv, TryStringToInt) {
1075   auto rv1 = folly::tryTo<int>("1000000000000000000000000000000");
1076   EXPECT_FALSE(rv1.hasValue());
1077   auto rv2 = folly::tryTo<int>("4711");
1078   EXPECT_TRUE(rv2.hasValue());
1079   EXPECT_EQ(rv2.value(), 4711);
1080 }
1081
1082 TEST(Conv, TryStringToEnum) {
1083   enum class A { x = 42, y = 420, z = 65 };
1084   auto rv1 = folly::tryTo<A>("1000000000000000000000000000000");
1085   EXPECT_FALSE(rv1.hasValue());
1086   auto rv2 = folly::tryTo<A>("42");
1087   EXPECT_TRUE(rv2.hasValue());
1088   EXPECT_EQ(A::x, rv2.value());
1089   auto rv3 = folly::tryTo<A>("50");
1090   EXPECT_TRUE(rv3.hasValue());
1091   EXPECT_EQ(static_cast<A>(50), rv3.value());
1092 }
1093
1094 TEST(Conv, TryStringToFloat) {
1095   auto rv1 = folly::tryTo<float>("");
1096   EXPECT_FALSE(rv1.hasValue());
1097   auto rv2 = folly::tryTo<float>("3.14");
1098   EXPECT_TRUE(rv2.hasValue());
1099   EXPECT_NEAR(rv2.value(), 3.14, 1e-5);
1100 }
1101
1102 TEST(Conv, TryStringToDouble) {
1103   auto rv1 = folly::tryTo<double>("");
1104   EXPECT_FALSE(rv1.hasValue());
1105   auto rv2 = folly::tryTo<double>("3.14");
1106   EXPECT_TRUE(rv2.hasValue());
1107   EXPECT_NEAR(rv2.value(), 3.14, 1e-10);
1108 }
1109
1110 TEST(Conv, TryIntToInt) {
1111   auto rv1 = folly::tryTo<uint8_t>(256);
1112   EXPECT_FALSE(rv1.hasValue());
1113   auto rv2 = folly::tryTo<uint8_t>(255);
1114   EXPECT_TRUE(rv2.hasValue());
1115   EXPECT_EQ(rv2.value(), 255);
1116 }
1117
1118 TEST(Conv, TryFloatToFloat) {
1119   auto rv1 = folly::tryTo<float>(1e100);
1120   EXPECT_FALSE(rv1.hasValue());
1121   auto rv2 = folly::tryTo<double>(25.5f);
1122   EXPECT_TRUE(rv2.hasValue());
1123   EXPECT_NEAR(rv2.value(), 25.5, 1e-10);
1124 }
1125
1126 TEST(Conv, TryFloatToInt) {
1127   auto rv1 = folly::tryTo<int>(100.001);
1128   EXPECT_FALSE(rv1.hasValue());
1129   auto rv2 = folly::tryTo<int>(100.0);
1130   EXPECT_TRUE(rv2.hasValue());
1131   EXPECT_EQ(rv2.value(), 100);
1132 }
1133
1134 TEST(Conv, TryIntToFloat) {
1135   auto rv1 = folly::tryTo<float>(std::numeric_limits<uint64_t>::max());
1136   EXPECT_FALSE(rv1.hasValue());
1137   auto rv2 = folly::tryTo<float>(1000ULL);
1138   EXPECT_TRUE(rv2.hasValue());
1139   EXPECT_EQ(rv2.value(), 1000.0f);
1140 }
1141
1142 TEST(Conv, TryPtrPairToInt) {
1143   StringPiece sp1("1000000000000000000000000000000");
1144   auto rv1 = folly::tryTo<int>(sp1.begin(), sp1.end());
1145   EXPECT_FALSE(rv1.hasValue());
1146   StringPiece sp2("4711");
1147   auto rv2 = folly::tryTo<int>(sp2.begin(), sp2.end());
1148   EXPECT_TRUE(rv2.hasValue());
1149   EXPECT_EQ(rv2.value(), 4711);
1150   StringPiece sp3("-4711");
1151   auto rv3 = folly::tryTo<int>(sp3.begin(), sp3.end());
1152   EXPECT_TRUE(rv3.hasValue());
1153   EXPECT_EQ(rv3.value(), -4711);
1154   StringPiece sp4("4711");
1155   auto rv4 = folly::tryTo<uint16_t>(sp4.begin(), sp4.end());
1156   EXPECT_TRUE(rv4.hasValue());
1157   EXPECT_EQ(rv4.value(), 4711);
1158 }
1159
1160 TEST(Conv, NewUint64ToString) {
1161   char buf[21];
1162
1163 #define THE_GREAT_EXPECTATIONS(n, len)                  \
1164   do {                                                  \
1165     EXPECT_EQ((len), uint64ToBufferUnsafe((n), buf));   \
1166     buf[(len)] = 0;                                     \
1167     auto s = string(#n);                                \
1168     s = s.substr(0, s.size() - 2);                      \
1169     EXPECT_EQ(s, buf);                                  \
1170   } while (0)
1171
1172   THE_GREAT_EXPECTATIONS(0UL, 1);
1173   THE_GREAT_EXPECTATIONS(1UL, 1);
1174   THE_GREAT_EXPECTATIONS(12UL, 2);
1175   THE_GREAT_EXPECTATIONS(123UL, 3);
1176   THE_GREAT_EXPECTATIONS(1234UL, 4);
1177   THE_GREAT_EXPECTATIONS(12345UL, 5);
1178   THE_GREAT_EXPECTATIONS(123456UL, 6);
1179   THE_GREAT_EXPECTATIONS(1234567UL, 7);
1180   THE_GREAT_EXPECTATIONS(12345678UL, 8);
1181   THE_GREAT_EXPECTATIONS(123456789UL, 9);
1182   THE_GREAT_EXPECTATIONS(1234567890UL, 10);
1183   THE_GREAT_EXPECTATIONS(12345678901UL, 11);
1184   THE_GREAT_EXPECTATIONS(123456789012UL, 12);
1185   THE_GREAT_EXPECTATIONS(1234567890123UL, 13);
1186   THE_GREAT_EXPECTATIONS(12345678901234UL, 14);
1187   THE_GREAT_EXPECTATIONS(123456789012345UL, 15);
1188   THE_GREAT_EXPECTATIONS(1234567890123456UL, 16);
1189   THE_GREAT_EXPECTATIONS(12345678901234567UL, 17);
1190   THE_GREAT_EXPECTATIONS(123456789012345678UL, 18);
1191   THE_GREAT_EXPECTATIONS(1234567890123456789UL, 19);
1192   THE_GREAT_EXPECTATIONS(18446744073709551614UL, 20);
1193   THE_GREAT_EXPECTATIONS(18446744073709551615UL, 20);
1194
1195 #undef THE_GREAT_EXPECTATIONS
1196 }
1197
1198 TEST(Conv, allocate_size) {
1199   std::string str1 = "meh meh meh";
1200   std::string str2 = "zdech zdech zdech";
1201
1202   auto res1 = folly::to<std::string>(str1, ".", str2);
1203   EXPECT_EQ(res1, str1 + "." + str2);
1204
1205   std::string res2; //empty
1206   toAppendFit(str1, str2, 1, &res2);
1207   EXPECT_EQ(res2, str1 + str2 + "1");
1208
1209   std::string res3;
1210   toAppendDelimFit(",", str1, str2, &res3);
1211   EXPECT_EQ(res3, str1 + "," + str2);
1212 }
1213
1214 namespace my {
1215 struct Dimensions {
1216   int w, h;
1217   std::tuple<const int&, const int&> tuple_view() const {
1218     return tie(w, h);
1219   }
1220   bool operator==(const Dimensions& other) const {
1221     return this->tuple_view() == other.tuple_view();
1222   }
1223 };
1224
1225 Expected<StringPiece, ConversionCode> parseTo(
1226     folly::StringPiece in,
1227     Dimensions& out) {
1228   return parseTo(in, out.w)
1229       .then([](StringPiece sp) { return sp.removePrefix("x"), sp; })
1230       .then([&](StringPiece sp) { return parseTo(sp, out.h); });
1231 }
1232
1233 template <class String>
1234 void toAppend(const Dimensions& in, String* result) {
1235   folly::toAppend(in.w, 'x', in.h, result);
1236 }
1237
1238 size_t estimateSpaceNeeded(const Dimensions&in) {
1239   return 2000 + folly::estimateSpaceNeeded(in.w) +
1240       folly::estimateSpaceNeeded(in.h);
1241 }
1242 }
1243
1244 TEST(Conv, custom_kkproviders) {
1245   my::Dimensions expected{7, 8};
1246   EXPECT_EQ(expected, folly::to<my::Dimensions>("7x8"));
1247   auto str = folly::to<std::string>(expected);
1248   EXPECT_EQ("7x8", str);
1249   // make sure above implementation of estimateSpaceNeeded() is used.
1250   EXPECT_GT(str.capacity(), 2000);
1251   EXPECT_LT(str.capacity(), 2500);
1252 }
1253
1254 TEST(Conv, TryToThenWithVoid) {
1255   auto x = tryTo<int>("42").then([](int) {});
1256   EXPECT_TRUE(x.hasValue());
1257   Unit u = x.value();
1258   (void)u;
1259 }