folly/test/ConvTest.cpp

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