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