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