2 * Copyright 2017 Facebook, Inc.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #ifndef __STDC_FORMAT_MACROS
18 #define __STDC_FORMAT_MACROS 1
21 #include <boost/lexical_cast.hpp>
23 #include <folly/Conv.h>
24 #include <folly/container/Foreach.h>
25 #include <folly/portability/GTest.h>
35 using namespace folly;
38 TEST(Conv, digits10) {
42 // first, some basic sniff tests
43 EXPECT_EQ( 1, digits10(0));
44 EXPECT_EQ( 1, digits10(1));
45 EXPECT_EQ( 1, digits10(9));
46 EXPECT_EQ( 2, digits10(10));
47 EXPECT_EQ( 2, digits10(99));
48 EXPECT_EQ( 3, digits10(100));
49 EXPECT_EQ( 3, digits10(999));
50 EXPECT_EQ( 4, digits10(1000));
51 EXPECT_EQ( 4, digits10(9999));
52 EXPECT_EQ(20, digits10(18446744073709551615ULL));
54 // try the first X nonnegatives.
55 // Covers some more cases of 2^p, 10^p
56 for (uint64_t i = 0; i < 100000; i++) {
57 snprintf(buffer, sizeof(buffer), "%" PRIu64, i);
58 EXPECT_EQ(strlen(buffer), digits10(i));
63 for (int p = 0; p < 64; p++) {
64 snprintf(buffer, sizeof(buffer), "%" PRIu64, power);
65 EXPECT_EQ(strlen(buffer), digits10(power));
66 snprintf(buffer, sizeof(buffer), "%" PRIu64, power - 1);
67 EXPECT_EQ(strlen(buffer), digits10(power - 1));
68 snprintf(buffer, sizeof(buffer), "%" PRIu64, power + 1);
69 EXPECT_EQ(strlen(buffer), digits10(power + 1));
75 for (int p = 0; p < 20; p++) {
76 snprintf(buffer, sizeof(buffer), "%" PRIu64, power);
77 EXPECT_EQ(strlen(buffer), digits10(power));
78 snprintf(buffer, sizeof(buffer), "%" PRIu64, power - 1);
79 EXPECT_EQ(strlen(buffer), digits10(power - 1));
80 snprintf(buffer, sizeof(buffer), "%" PRIu64, power + 1);
81 EXPECT_EQ(strlen(buffer), digits10(power + 1));
87 TEST(Conv, Type2Type) {
89 EXPECT_EQ(to<bool>(boolV), true);
92 EXPECT_EQ(to<int>(intV), 42);
95 EXPECT_EQ(to<float>(floatV), 4.2f);
97 double doubleV = 0.42;
98 EXPECT_EQ(to<double>(doubleV), 0.42);
100 std::string stringV = "StdString";
101 EXPECT_EQ(to<std::string>(stringV), "StdString");
103 folly::fbstring fbStrV = "FBString";
104 EXPECT_EQ(to<folly::fbstring>(fbStrV), "FBString");
106 folly::StringPiece spV("StringPiece");
107 EXPECT_EQ(to<folly::StringPiece>(spV), "StringPiece");
110 EXPECT_EQ(to<bool>(true), true);
111 EXPECT_EQ(to<int>(42), 42);
112 EXPECT_EQ(to<float>(4.2f), 4.2f);
113 EXPECT_EQ(to<double>(.42), .42);
114 EXPECT_EQ(to<std::string>(std::string("Hello")), "Hello");
115 EXPECT_EQ(to<folly::fbstring>(folly::fbstring("hello")), "hello");
116 EXPECT_EQ(to<folly::StringPiece>(folly::StringPiece("Forty Two")),
120 TEST(Conv, Integral2Integral) {
121 // Same size, different signs
122 int64_t s64 = numeric_limits<uint8_t>::max();
123 EXPECT_EQ(to<uint8_t>(s64), s64);
125 s64 = numeric_limits<int8_t>::max();
126 EXPECT_EQ(to<int8_t>(s64), s64);
129 TEST(Conv, Floating2Floating) {
131 double d1 = to<double>(f1);
135 auto f2 = to<float>(d2);
136 EXPECT_EQ(double(f2), d2);
138 double invalidFloat = std::numeric_limits<double>::max();
139 EXPECT_ANY_THROW(to<float>(invalidFloat));
140 invalidFloat = -std::numeric_limits<double>::max();
141 EXPECT_ANY_THROW(to<float>(invalidFloat));
144 auto shouldWork = to<float>(std::numeric_limits<double>::min());
145 // The value of `shouldWork' is an implementation defined choice
146 // between the following two alternatives.
147 EXPECT_TRUE(shouldWork == std::numeric_limits<float>::min() ||
154 template <class String>
155 void testIntegral2String() {
158 template <class String, class Int, class... Ints>
159 void testIntegral2String() {
160 typedef typename make_unsigned<Int>::type Uint;
161 typedef typename make_signed<Int>::type Sint;
164 EXPECT_EQ(to<String>(value), "123");
166 EXPECT_EQ(to<String>(svalue), "123");
168 EXPECT_EQ(to<String>(svalue), "-123");
170 value = numeric_limits<Uint>::min();
171 EXPECT_EQ(to<Uint>(to<String>(value)), value);
172 value = numeric_limits<Uint>::max();
173 EXPECT_EQ(to<Uint>(to<String>(value)), value);
175 svalue = numeric_limits<Sint>::min();
176 EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
177 value = numeric_limits<Sint>::max();
178 EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
180 testIntegral2String<String, Ints...>();
183 #if FOLLY_HAVE_INT128_T
184 template <class String>
185 void test128Bit2String() {
186 typedef unsigned __int128 Uint;
187 typedef __int128 Sint;
189 EXPECT_EQ(detail::digitsEnough<unsigned __int128>(), 39);
192 EXPECT_EQ(to<String>(value), "123");
194 EXPECT_EQ(to<String>(svalue), "123");
196 EXPECT_EQ(to<String>(svalue), "-123");
198 value = __int128(1) << 64;
199 EXPECT_EQ(to<String>(value), "18446744073709551616");
201 svalue = -(__int128(1) << 64);
202 EXPECT_EQ(to<String>(svalue), "-18446744073709551616");
205 EXPECT_EQ(to<String>(value), "0");
208 EXPECT_EQ(to<String>(svalue), "0");
210 value = ~__int128(0);
211 EXPECT_EQ(to<String>(value), "340282366920938463463374607431768211455");
213 svalue = -(Uint(1) << 127);
214 EXPECT_EQ(to<String>(svalue), "-170141183460469231731687303715884105728");
216 svalue = (Uint(1) << 127) - 1;
217 EXPECT_EQ(to<String>(svalue), "170141183460469231731687303715884105727");
219 // TODO: the following do not compile to<__int128> ...
222 value = numeric_limits<Uint>::min();
223 EXPECT_EQ(to<Uint>(to<String>(value)), value);
224 value = numeric_limits<Uint>::max();
225 EXPECT_EQ(to<Uint>(to<String>(value)), value);
227 svalue = numeric_limits<Sint>::min();
228 EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
229 value = numeric_limits<Sint>::max();
230 EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
236 TEST(Conv, Integral2String) {
237 testIntegral2String<std::string, int8_t, int16_t, int32_t, int64_t>();
238 testIntegral2String<fbstring, int8_t, int16_t, int32_t, int64_t>();
240 #if FOLLY_HAVE_INT128_T
241 test128Bit2String<std::string>();
242 test128Bit2String<fbstring>();
246 template <class String>
247 void testString2Integral() {
250 template <class String, class Int, class... Ints>
251 void testString2Integral() {
252 typedef typename make_unsigned<Int>::type Uint;
253 typedef typename make_signed<Int>::type Sint;
255 // Unsigned numbers small enough to fit in a signed type
256 static const String strings[] = {
263 "0000000000000000000000000042"
265 static const Uint values[] = {
274 FOR_EACH_RANGE (i, 0, sizeof(strings) / sizeof(*strings)) {
275 EXPECT_EQ(to<Uint>(strings[i]), values[i]);
276 EXPECT_EQ(to<Sint>(strings[i]), values[i]);
279 // Unsigned numbers that won't fit in the signed variation
280 static const String uStrings[] = {
285 static const Uint uValues[] = {
290 FOR_EACH_RANGE (i, 0, sizeof(uStrings)/sizeof(*uStrings)) {
291 EXPECT_EQ(to<Uint>(uStrings[i]), uValues[i]);
292 if (sizeof(Int) == 1) {
293 EXPECT_THROW(to<Sint>(uStrings[i]), std::range_error);
297 if (sizeof(Int) >= 4) {
298 static const String strings2[] = {
304 static const Uint values2[] = {
310 FOR_EACH_RANGE (i, 0, sizeof(strings2)/sizeof(*strings2)) {
311 EXPECT_EQ(to<Uint>(strings2[i]), values2[i]);
312 EXPECT_EQ(to<Sint>(strings2[i]), values2[i]);
315 static const String uStrings2[] = {
321 static const Uint uValues2[] = {
327 FOR_EACH_RANGE (i, 0, sizeof(uStrings2)/sizeof(uStrings2)) {
328 EXPECT_EQ(to<Uint>(uStrings2[i]), uValues2[i]);
329 if (sizeof(Int) == 4) {
330 EXPECT_THROW(to<Sint>(uStrings2[i]), std::range_error);
335 if (sizeof(Int) >= 8) {
336 static_assert(sizeof(Int) <= 8, "Now that would be interesting");
337 static const String strings3[] = {
341 "100000000000000000",
342 "9223372036854775807",
344 static const Uint values3[] = {
347 (Uint)25687346509278435ULL,
348 (Uint)100000000000000000ULL,
349 (Uint)9223372036854775807ULL,
351 FOR_EACH_RANGE (i, 0, sizeof(strings3)/sizeof(*strings3)) {
352 EXPECT_EQ(to<Uint>(strings3[i]), values3[i]);
353 EXPECT_EQ(to<Sint>(strings3[i]), values3[i]);
356 static const String uStrings3[] = {
357 "9223372036854775808",
358 "9987435987394857987",
359 "17873648761234698740",
360 "18446744073709551615",
362 static const Uint uValues3[] = {
363 (Uint)9223372036854775808ULL,
364 (Uint)9987435987394857987ULL,
365 (Uint)17873648761234698740ULL,
366 (Uint)18446744073709551615ULL,
368 FOR_EACH_RANGE (i, 0, sizeof(uStrings3)/sizeof(*uStrings3)) {
369 EXPECT_EQ(to<Uint>(uStrings3[i]), uValues3[i]);
370 if (sizeof(Int) == 8) {
371 EXPECT_THROW(to<Sint>(uStrings3[i]), std::range_error);
376 // Minimum possible negative values, and negative sign overflow
377 static const String strings4[] = {
381 "-9223372036854775808",
383 static const String strings5[] = {
387 "-9223372036854775809",
389 static const Sint values4[] = {
393 (Sint)(-9223372036854775807LL - 1),
395 FOR_EACH_RANGE (i, 0, sizeof(strings4)/sizeof(*strings4)) {
396 if (sizeof(Int) > std::pow(2, i)) {
397 EXPECT_EQ(values4[i], to<Sint>(strings4[i]));
398 EXPECT_EQ(values4[i] - 1, to<Sint>(strings5[i]));
399 } else if (sizeof(Int) == std::pow(2, i)) {
400 EXPECT_EQ(values4[i], to<Sint>(strings4[i]));
401 EXPECT_THROW(to<Sint>(strings5[i]), std::range_error);
403 EXPECT_THROW(to<Sint>(strings4[i]), std::range_error);
404 EXPECT_THROW(to<Sint>(strings5[i]), std::range_error);
408 // Bogus string values
409 static const String bogusStrings[] = {
416 "- 42", // whitespace is not allowed between the sign and the value
418 "12345678901234567890123456789",
420 for (const auto& str : bogusStrings) {
421 EXPECT_THROW(to<Sint>(str), std::range_error);
422 EXPECT_THROW(to<Uint>(str), std::range_error);
425 // A leading '+' character is only allowed when converting to signed types.
426 String posSign("+42");
427 EXPECT_EQ(42, to<Sint>(posSign));
428 EXPECT_THROW(to<Uint>(posSign), std::range_error);
430 testString2Integral<String, Ints...>();
433 TEST(Conv, String2Integral) {
434 testString2Integral<const char*, int8_t, int16_t, int32_t, int64_t>();
435 testString2Integral<std::string, int8_t, int16_t, int32_t, int64_t>();
436 testString2Integral<fbstring, int8_t, int16_t, int32_t, int64_t>();
438 // Testing the behavior of the StringPiece* API
439 // StringPiece* normally parses as much valid data as it can,
440 // and advances the StringPiece to the end of the valid data.
441 char buf1[] = "100foo";
442 StringPiece sp1(buf1);
443 EXPECT_EQ(100, to<uint8_t>(&sp1));
444 EXPECT_EQ(buf1 + 3, sp1.begin());
445 // However, if the next character would cause an overflow it throws a
446 // range_error rather than consuming only as much as it can without
448 char buf2[] = "1002";
449 StringPiece sp2(buf2);
450 EXPECT_THROW(to<uint8_t>(&sp2), std::range_error);
451 EXPECT_EQ(buf2, sp2.begin());
454 TEST(Conv, StringPiece2Integral) {
455 string s = " +123 hello world ";
457 EXPECT_EQ(to<int>(&sp), 123);
458 EXPECT_EQ(sp, " hello world ");
461 TEST(Conv, StringPieceAppend) {
464 StringPiece sp(s, 0, 3);
465 string result = to<string>(s, sp);
466 EXPECT_EQ(result, "foobarfoo");
469 StringPiece sp1(s, 0, 3);
470 StringPiece sp2(s, 3, 3);
471 string result = to<string>(sp1, sp2);
472 EXPECT_EQ(result, s);
476 TEST(Conv, BadStringToIntegral) {
477 // Note that leading spaces (e.g. " 1") are valid.
478 vector<string> v = { "a", "", " ", "\n", " a0", "abcdef", "1Z", "!#" };
480 EXPECT_THROW(to<int>(s), std::range_error) << "s=" << s;
484 template <class String>
485 void testIdenticalTo() {
486 String s("Yukkuri shiteitte ne!!!");
488 String result = to<String>(s);
489 EXPECT_EQ(result, s);
492 template <class String>
493 void testVariadicTo() {
496 toAppend("Lorem ipsum ", 1234, String(" dolor amet "), 567.89, '!', &s);
497 EXPECT_EQ(s, "Lorem ipsum 1234 dolor amet 567.89!");
500 EXPECT_TRUE(s.empty());
502 s = to<String>("Lorem ipsum ", nullptr, 1234, " dolor amet ", 567.89, '.');
503 EXPECT_EQ(s, "Lorem ipsum 1234 dolor amet 567.89.");
506 template <class String>
507 void testIdenticalToDelim() {
508 String s("Yukkuri shiteitte ne!!!");
510 String charDelim = toDelim<String>('$', s);
511 EXPECT_EQ(charDelim, s);
513 String strDelim = toDelim<String>(String(">_<"), s);
514 EXPECT_EQ(strDelim, s);
517 template <class String>
518 void testVariadicToDelim() {
520 toAppendDelim(":", &s);
522 ":", "Lorem ipsum ", 1234, String(" dolor amet "), 567.89, '!', &s);
523 EXPECT_EQ(s, "Lorem ipsum :1234: dolor amet :567.89:!");
525 s = toDelim<String>(':');
526 EXPECT_TRUE(s.empty());
529 ":", "Lorem ipsum ", nullptr, 1234, " dolor amet ", 567.89, '.');
530 EXPECT_EQ(s, "Lorem ipsum ::1234: dolor amet :567.89:.");
533 TEST(Conv, NullString) {
534 string s1 = to<string>((char *) nullptr);
535 EXPECT_TRUE(s1.empty());
536 fbstring s2 = to<fbstring>((char *) nullptr);
537 EXPECT_TRUE(s2.empty());
540 TEST(Conv, VariadicTo) {
541 testIdenticalTo<string>();
542 testIdenticalTo<fbstring>();
543 testVariadicTo<string>();
544 testVariadicTo<fbstring>();
547 TEST(Conv, VariadicToDelim) {
548 testIdenticalToDelim<string>();
549 testIdenticalToDelim<fbstring>();
550 testVariadicToDelim<string>();
551 testVariadicToDelim<fbstring>();
554 template <class String>
555 void testDoubleToString() {
556 EXPECT_EQ(to<string>(0.0), "0");
557 EXPECT_EQ(to<string>(0.5), "0.5");
558 EXPECT_EQ(to<string>(10.25), "10.25");
559 EXPECT_EQ(to<string>(1.123e10), "11230000000");
562 TEST(Conv, DoubleToString) {
563 testDoubleToString<string>();
564 testDoubleToString<fbstring>();
567 TEST(Conv, FBStringToString) {
569 string ret = to<string>(foo);
570 EXPECT_EQ(ret, "foo");
571 string ret2 = to<string>(foo, 2);
572 EXPECT_EQ(ret2, "foo2");
575 TEST(Conv, StringPieceToDouble) {
576 vector<tuple<const char*, const char*, double>> strs{
577 make_tuple("2134123.125 zorro", " zorro", 2134123.125),
578 make_tuple(" 2134123.125 zorro", " zorro", 2134123.125),
579 make_tuple(" 2134123.125 zorro", " zorro", 2134123.125),
580 make_tuple(" 2134123.125 zorro ", " zorro ", 2134123.125),
581 make_tuple("2134123.125zorro", "zorro", 2134123.125),
582 make_tuple("0 zorro", " zorro", 0.0),
583 make_tuple(" 0 zorro", " zorro", 0.0),
584 make_tuple(" 0 zorro", " zorro", 0.0),
585 make_tuple(" 0 zorro ", " zorro ", 0.0),
586 make_tuple("0zorro", "zorro", 0.0),
587 make_tuple("0.0 zorro", " zorro", 0.0),
588 make_tuple(" 0.0 zorro", " zorro", 0.0),
589 make_tuple(" 0.0 zorro", " zorro", 0.0),
590 make_tuple(" 0.0 zorro ", " zorro ", 0.0),
591 make_tuple("0.0zorro", "zorro", 0.0),
593 for (const auto& s : strs) {
594 StringPiece pc(get<0>(s));
595 EXPECT_EQ(get<2>(s), to<double>(&pc)) << "\"" << get<0>(s) << "\"";
596 EXPECT_EQ(get<1>(s), pc);
597 EXPECT_THROW(to<double>(StringPiece(get<0>(s))), std::range_error);
598 EXPECT_EQ(get<2>(s), to<double>(StringPiece(get<0>(s), pc.data())));
601 // Test NaN conversion
603 to<double>("not a number");
605 } catch (const std::range_error &) {
608 EXPECT_TRUE(std::isnan(to<double>("nan")));
609 EXPECT_TRUE(std::isnan(to<double>("NaN")));
610 EXPECT_TRUE(std::isnan(to<double>("NAN")));
611 EXPECT_TRUE(std::isnan(to<double>("-nan")));
612 EXPECT_TRUE(std::isnan(to<double>("-NaN")));
613 EXPECT_TRUE(std::isnan(to<double>("-NAN")));
615 EXPECT_EQ(to<double>("inf"), numeric_limits<double>::infinity());
616 EXPECT_EQ(to<double>("Inf"), numeric_limits<double>::infinity());
617 EXPECT_EQ(to<double>("INF"), numeric_limits<double>::infinity());
618 EXPECT_EQ(to<double>("inF"), numeric_limits<double>::infinity());
619 EXPECT_EQ(to<double>("infinity"), numeric_limits<double>::infinity());
620 EXPECT_EQ(to<double>("Infinity"), numeric_limits<double>::infinity());
621 EXPECT_EQ(to<double>("INFINITY"), numeric_limits<double>::infinity());
622 EXPECT_EQ(to<double>("iNfInItY"), numeric_limits<double>::infinity());
623 EXPECT_THROW(to<double>("infinitX"), std::range_error);
624 EXPECT_EQ(to<double>("-inf"), -numeric_limits<double>::infinity());
625 EXPECT_EQ(to<double>("-Inf"), -numeric_limits<double>::infinity());
626 EXPECT_EQ(to<double>("-INF"), -numeric_limits<double>::infinity());
627 EXPECT_EQ(to<double>("-inF"), -numeric_limits<double>::infinity());
628 EXPECT_EQ(to<double>("-infinity"), -numeric_limits<double>::infinity());
629 EXPECT_EQ(to<double>("-Infinity"), -numeric_limits<double>::infinity());
630 EXPECT_EQ(to<double>("-INFINITY"), -numeric_limits<double>::infinity());
631 EXPECT_EQ(to<double>("-iNfInItY"), -numeric_limits<double>::infinity());
632 EXPECT_THROW(to<double>("-infinitX"), std::range_error);
635 TEST(Conv, EmptyStringToInt) {
642 } catch (const std::range_error &) {
646 TEST(Conv, CorruptedStringToInt) {
648 StringPiece pc(s.data(), s.data() + 1); // Only "-"
653 } catch (const std::range_error &) {
657 TEST(Conv, EmptyStringToDouble) {
664 } catch (const std::range_error &) {
668 TEST(Conv, IntToDouble) {
669 auto d = to<double>(42);
671 /* This seems not work in ubuntu11.10, gcc 4.6.1
673 auto f = to<float>(957837589847);
675 } catch (std::range_error& e) {
676 //LOG(INFO) << e.what();
681 TEST(Conv, DoubleToInt) {
682 auto i = to<int>(42.0);
685 auto i2 = to<int>(42.1);
686 LOG(ERROR) << "to<int> returned " << i2 << " instead of throwing";
688 } catch (std::range_error&) {
689 //LOG(INFO) << e.what();
693 TEST(Conv, EnumToInt) {
694 enum A { x = 42, y = 420, z = 65 };
697 auto j = to<char>(x);
700 auto i2 = to<char>(y);
701 LOG(ERROR) << "to<char> returned "
702 << static_cast<unsigned int>(i2)
703 << " instead of throwing";
705 } catch (std::range_error&) {
706 //LOG(INFO) << e.what();
710 TEST(Conv, EnumToString) {
712 enum A { x = 4, y = 420, z = 65 };
713 EXPECT_EQ("foo.4", to<string>("foo.", x));
714 EXPECT_EQ("foo.420", to<string>("foo.", y));
715 EXPECT_EQ("foo.65", to<string>("foo.", z));
718 TEST(Conv, IntToEnum) {
719 enum A { x = 42, y = 420 };
725 auto i2 = to<A>(5000000000L);
726 LOG(ERROR) << "to<A> returned "
727 << static_cast<unsigned int>(i2)
728 << " instead of throwing";
730 } catch (std::range_error&) {
731 //LOG(INFO) << e.what();
735 TEST(Conv, UnsignedEnum) {
736 enum E : uint32_t { x = 3000000000U };
737 auto u = to<uint32_t>(x);
738 EXPECT_EQ(u, 3000000000U);
739 auto s = to<string>(x);
740 EXPECT_EQ("3000000000", s);
741 auto e = to<E>(3000000000U);
744 auto i = to<int32_t>(x);
745 LOG(ERROR) << "to<int32_t> returned " << i << " instead of throwing";
747 } catch (std::range_error&) {
751 TEST(Conv, UnsignedEnumClass) {
752 enum class E : uint32_t { x = 3000000000U };
753 auto u = to<uint32_t>(E::x);
755 EXPECT_EQ(u, 3000000000U);
756 EXPECT_EQ("3000000000", to<string>(E::x));
757 EXPECT_EQ(E::x, to<E>(3000000000U));
758 EXPECT_EQ(E::x, to<E>("3000000000"));
760 EXPECT_TRUE(parseTo("3000000000", e).hasValue());
762 EXPECT_THROW(to<int32_t>(E::x), std::range_error);
765 // Multi-argument to<string> uses toAppend, a different code path than
767 TEST(Conv, EnumClassToString) {
768 enum class A { x = 4, y = 420, z = 65 };
769 EXPECT_EQ("foo.4", to<string>("foo.", A::x));
770 EXPECT_EQ("foo.420", to<string>("foo.", A::y));
771 EXPECT_EQ("foo.65", to<string>("foo.", A::z));
774 TEST(Conv, IntegralToBool) {
775 EXPECT_FALSE(to<bool>(0));
776 EXPECT_FALSE(to<bool>(0ul));
778 EXPECT_TRUE(to<bool>(1));
779 EXPECT_TRUE(to<bool>(1ul));
781 EXPECT_TRUE(to<bool>(-42));
782 EXPECT_TRUE(to<bool>(42ul));
785 template <typename Src>
786 void testStr2Bool() {
787 EXPECT_FALSE(to<bool>(Src("0")));
788 EXPECT_FALSE(to<bool>(Src(" 000 ")));
790 EXPECT_FALSE(to<bool>(Src("n")));
791 EXPECT_FALSE(to<bool>(Src("no")));
792 EXPECT_FALSE(to<bool>(Src("false")));
793 EXPECT_FALSE(to<bool>(Src("False")));
794 EXPECT_FALSE(to<bool>(Src(" fAlSe" )));
795 EXPECT_FALSE(to<bool>(Src("F")));
796 EXPECT_FALSE(to<bool>(Src("off")));
798 EXPECT_TRUE(to<bool>(Src("1")));
799 EXPECT_TRUE(to<bool>(Src(" 001 ")));
800 EXPECT_TRUE(to<bool>(Src("y")));
801 EXPECT_TRUE(to<bool>(Src("yes")));
802 EXPECT_TRUE(to<bool>(Src("\nyEs\t")));
803 EXPECT_TRUE(to<bool>(Src("true")));
804 EXPECT_TRUE(to<bool>(Src("True")));
805 EXPECT_TRUE(to<bool>(Src("T")));
806 EXPECT_TRUE(to<bool>(Src("on")));
808 EXPECT_THROW(to<bool>(Src("")), std::range_error);
809 EXPECT_THROW(to<bool>(Src("2")), std::range_error);
810 EXPECT_THROW(to<bool>(Src("11")), std::range_error);
811 EXPECT_THROW(to<bool>(Src("19")), std::range_error);
812 EXPECT_THROW(to<bool>(Src("o")), std::range_error);
813 EXPECT_THROW(to<bool>(Src("fal")), std::range_error);
814 EXPECT_THROW(to<bool>(Src("tru")), std::range_error);
815 EXPECT_THROW(to<bool>(Src("ye")), std::range_error);
816 EXPECT_THROW(to<bool>(Src("yes foo")), std::range_error);
817 EXPECT_THROW(to<bool>(Src("bar no")), std::range_error);
818 EXPECT_THROW(to<bool>(Src("one")), std::range_error);
819 EXPECT_THROW(to<bool>(Src("true_")), std::range_error);
820 EXPECT_THROW(to<bool>(Src("bogus_token_that_is_too_long")),
824 TEST(Conv, StringToBool) {
825 // testStr2Bool<const char *>();
826 testStr2Bool<std::string>();
828 // Test with strings that are not NUL terminated.
829 const char buf[] = "01234";
830 EXPECT_FALSE(to<bool>(StringPiece(buf, buf + 1))); // "0"
831 EXPECT_TRUE(to<bool>(StringPiece(buf + 1, buf + 2))); // "1"
832 const char buf2[] = "one two three";
833 EXPECT_TRUE(to<bool>(StringPiece(buf2, buf2 + 2))); // "on"
834 const char buf3[] = "false";
835 EXPECT_THROW(to<bool>(StringPiece(buf3, buf3 + 3)), // "fal"
838 // Test the StringPiece* API
839 const char buf4[] = "001foo";
840 StringPiece sp4(buf4);
841 EXPECT_TRUE(to<bool>(&sp4));
842 EXPECT_EQ(buf4 + 3, sp4.begin());
843 const char buf5[] = "0012";
844 StringPiece sp5(buf5);
845 EXPECT_THROW(to<bool>(&sp5), std::range_error);
846 EXPECT_EQ(buf5, sp5.begin());
849 TEST(Conv, Transform) {
850 const std::vector<int64_t> in{1, 2, 3};
851 std::vector<std::string> out(in.size());
852 std::transform(in.begin(), in.end(), out.begin(), to<std::string, int64_t>);
853 const std::vector<std::string> ref{"1", "2", "3"};
857 TEST(Conv, FloatToInt) {
858 EXPECT_EQ(to<int>(42.0f), 42);
859 EXPECT_EQ(to<int8_t>(-128.0f), int8_t(-128));
860 EXPECT_THROW(to<int8_t>(-129.0), std::range_error);
861 EXPECT_THROW(to<int8_t>(127.001), std::range_error);
862 EXPECT_THROW(to<uint8_t>(-0.0001), std::range_error);
864 to<uint64_t>(static_cast<float>(std::numeric_limits<uint64_t>::max())),
868 TEST(Conv, IntToFloat) {
869 EXPECT_EQ(to<float>(42ULL), 42.0);
870 EXPECT_EQ(to<float>(int8_t(-128)), -128.0);
872 to<float>(std::numeric_limits<uint64_t>::max()), std::range_error);
874 to<float>(std::numeric_limits<int64_t>::max()), std::range_error);
876 to<float>(std::numeric_limits<int64_t>::min() + 1), std::range_error);
877 #if FOLLY_HAVE_INT128_T
879 to<double>(std::numeric_limits<unsigned __int128>::max()),
882 to<double>(std::numeric_limits<__int128>::max()), std::range_error);
884 to<double>(std::numeric_limits<__int128>::min() + 1), std::range_error);
888 TEST(Conv, BoolToFloat) {
889 EXPECT_EQ(to<double>(true), 1.0);
890 EXPECT_EQ(to<double>(false), 0.0);
893 TEST(Conv, FloatToBool) {
894 EXPECT_EQ(to<bool>(1.0), true);
895 EXPECT_EQ(to<bool>(0.0), false);
896 EXPECT_EQ(to<bool>(2.7), true);
897 EXPECT_EQ(to<bool>(std::numeric_limits<double>::max()), true);
898 EXPECT_EQ(to<bool>(std::numeric_limits<double>::min()), true);
899 EXPECT_EQ(to<bool>(std::numeric_limits<double>::lowest()), true);
900 EXPECT_EQ(to<bool>(std::numeric_limits<double>::quiet_NaN()), true);
901 EXPECT_EQ(to<bool>(std::numeric_limits<double>::infinity()), true);
902 EXPECT_EQ(to<bool>(-std::numeric_limits<double>::infinity()), true);
907 template <typename F>
915 std::string where = to<std::string>(__FILE__, "(", line, "): ");
918 ADD_FAILURE() << where << exprStr << " -> " << res;
919 } catch (const ConversionError& e) {
920 EXPECT_EQ(code, e.errorCode()) << where << exprStr;
921 std::string str(e.what());
922 EXPECT_FALSE(str.empty()) << where << exprStr << " -> " << str;
923 auto pos = str.find(':');
925 std::ostringstream exp;
926 exp << str.substr(0, pos) + ": ";
928 exp << "\"" << value << "\"";
932 EXPECT_EQ(exp.str(), str) << where << exprStr << " -> " << str;
934 EXPECT_EQ(pos, std::string::npos) << where << exprStr << " -> " << str;
940 #define EXPECT_CONV_ERROR_QUOTE(expr, code, value, quoted) \
942 [&] { return expr; }, \
944 ConversionCode::code, \
949 #define EXPECT_CONV_ERROR(expr, code, value) \
950 EXPECT_CONV_ERROR_QUOTE(expr, code, value, true)
952 #define EXPECT_CONV_ERROR_STR(type, str, code) \
953 EXPECT_CONV_ERROR(to<type>(str), code, str)
955 #define EXPECT_CONV_ERROR_STR_NOVAL(type, str, code) \
956 EXPECT_CONV_ERROR(to<type>(str), code, nullptr)
958 TEST(Conv, ConversionErrorStrToBool) {
959 EXPECT_CONV_ERROR_STR_NOVAL(bool, StringPiece(), EMPTY_INPUT_STRING);
960 EXPECT_CONV_ERROR_STR_NOVAL(bool, "", EMPTY_INPUT_STRING);
961 EXPECT_CONV_ERROR_STR(bool, " ", EMPTY_INPUT_STRING);
962 EXPECT_CONV_ERROR_STR(bool, " 11 ", BOOL_OVERFLOW);
963 EXPECT_CONV_ERROR_STR(bool, "other ", BOOL_INVALID_VALUE);
964 EXPECT_CONV_ERROR_STR(bool, " bla", BOOL_INVALID_VALUE);
965 EXPECT_CONV_ERROR(to<bool>(" offbla"), NON_WHITESPACE_AFTER_END, "bla");
968 TEST(Conv, ConversionErrorStrToFloat) {
969 EXPECT_CONV_ERROR_STR_NOVAL(float, StringPiece(), EMPTY_INPUT_STRING);
970 EXPECT_CONV_ERROR_STR_NOVAL(float, "", EMPTY_INPUT_STRING);
971 EXPECT_CONV_ERROR_STR(float, " ", EMPTY_INPUT_STRING);
972 EXPECT_CONV_ERROR_STR(float, " junk", STRING_TO_FLOAT_ERROR);
973 EXPECT_CONV_ERROR(to<float>(" 1bla"), NON_WHITESPACE_AFTER_END, "bla");
976 TEST(Conv, ConversionErrorStrToInt) {
977 // empty string handling
978 EXPECT_CONV_ERROR_STR_NOVAL(int, StringPiece(), EMPTY_INPUT_STRING);
979 EXPECT_CONV_ERROR_STR_NOVAL(int, "", EMPTY_INPUT_STRING);
980 EXPECT_CONV_ERROR_STR(int, " ", EMPTY_INPUT_STRING);
983 EXPECT_CONV_ERROR_STR(int, " *", INVALID_LEADING_CHAR);
984 EXPECT_CONV_ERROR_STR(int, " +", NO_DIGITS);
985 EXPECT_CONV_ERROR_STR(int, " +*", NON_DIGIT_CHAR);
986 EXPECT_CONV_ERROR_STR(int8_t, " 128", POSITIVE_OVERFLOW);
987 EXPECT_CONV_ERROR_STR(int8_t, " -129", NEGATIVE_OVERFLOW);
988 EXPECT_CONV_ERROR_STR(int8_t, " 1000", POSITIVE_OVERFLOW);
989 EXPECT_CONV_ERROR_STR(int8_t, "-1000", NEGATIVE_OVERFLOW);
990 EXPECT_CONV_ERROR(to<int>(" -13bla"), NON_WHITESPACE_AFTER_END, "bla");
993 EXPECT_CONV_ERROR_STR(unsigned, " -", NON_DIGIT_CHAR);
994 EXPECT_CONV_ERROR_STR(uint8_t, " 256", POSITIVE_OVERFLOW);
995 EXPECT_CONV_ERROR(to<unsigned>("42bla"), NON_WHITESPACE_AFTER_END, "bla");
998 #define EXPECT_CONV_ERROR_PP_VAL(type, str, code, val) \
1000 StringPiece input(str); \
1001 EXPECT_CONV_ERROR(to<type>(input.begin(), input.end()), code, val); \
1004 #define EXPECT_CONV_ERROR_PP(type, str, code) \
1005 EXPECT_CONV_ERROR_PP_VAL(type, str, code, str)
1007 TEST(Conv, ConversionErrorPtrPairToInt) {
1009 EXPECT_CONV_ERROR_PP(int, "", INVALID_LEADING_CHAR);
1010 EXPECT_CONV_ERROR_PP(int, " ", INVALID_LEADING_CHAR);
1011 EXPECT_CONV_ERROR_PP(int, "*", INVALID_LEADING_CHAR);
1012 EXPECT_CONV_ERROR_PP(int, "+", NO_DIGITS);
1013 EXPECT_CONV_ERROR_PP(int8_t, "128", POSITIVE_OVERFLOW);
1014 EXPECT_CONV_ERROR_PP(int8_t, "-129", NEGATIVE_OVERFLOW);
1015 EXPECT_CONV_ERROR_PP(int8_t, "1000", POSITIVE_OVERFLOW);
1016 EXPECT_CONV_ERROR_PP(int8_t, "-1000", NEGATIVE_OVERFLOW);
1017 EXPECT_CONV_ERROR_PP(int, "-junk", NON_DIGIT_CHAR);
1019 // unsigned integers
1020 EXPECT_CONV_ERROR_PP(unsigned, "", NO_DIGITS);
1021 EXPECT_CONV_ERROR_PP(uint8_t, "256", POSITIVE_OVERFLOW);
1022 EXPECT_CONV_ERROR_PP(unsigned, "junk", NON_DIGIT_CHAR);
1027 template <typename T, typename V>
1028 std::string prefixWithType(V value) {
1029 std::ostringstream oss;
1030 #ifdef FOLLY_HAS_RTTI
1031 oss << "(" << demangle(typeid(T)) << ") ";
1033 oss << to<std::string>(value);
1038 #define EXPECT_CONV_ERROR_ARITH(type, val, code) \
1039 EXPECT_CONV_ERROR_QUOTE( \
1040 to<type>(val), code, prefixWithType<type>(val).c_str(), false)
1042 TEST(Conv, ConversionErrorIntToInt) {
1043 EXPECT_CONV_ERROR_ARITH(signed char, 128, ARITH_POSITIVE_OVERFLOW);
1044 EXPECT_CONV_ERROR_ARITH(unsigned char, -1, ARITH_NEGATIVE_OVERFLOW);
1047 TEST(Conv, ConversionErrorFloatToFloat) {
1048 EXPECT_CONV_ERROR_ARITH(
1049 float, std::numeric_limits<double>::max(), ARITH_POSITIVE_OVERFLOW);
1050 EXPECT_CONV_ERROR_ARITH(
1051 float, std::numeric_limits<double>::lowest(), ARITH_NEGATIVE_OVERFLOW);
1054 TEST(Conv, ConversionErrorIntToFloat) {
1055 EXPECT_CONV_ERROR_ARITH(
1056 float, std::numeric_limits<long long>::max(), ARITH_LOSS_OF_PRECISION);
1059 TEST(Conv, ConversionErrorFloatToInt) {
1060 EXPECT_CONV_ERROR_ARITH(int8_t, 65.5, ARITH_LOSS_OF_PRECISION);
1063 TEST(Conv, TryStringToBool) {
1064 auto rv1 = folly::tryTo<bool>("xxxx");
1065 EXPECT_FALSE(rv1.hasValue());
1066 auto rv2 = folly::tryTo<bool>("false");
1067 EXPECT_TRUE(rv2.hasValue());
1068 EXPECT_FALSE(rv2.value());
1069 auto rv3 = folly::tryTo<bool>("yes");
1070 EXPECT_TRUE(rv3.hasValue());
1071 EXPECT_TRUE(rv3.value());
1074 TEST(Conv, TryStringToInt) {
1075 auto rv1 = folly::tryTo<int>("1000000000000000000000000000000");
1076 EXPECT_FALSE(rv1.hasValue());
1077 auto rv2 = folly::tryTo<int>("4711");
1078 EXPECT_TRUE(rv2.hasValue());
1079 EXPECT_EQ(rv2.value(), 4711);
1082 TEST(Conv, TryStringToEnum) {
1083 enum class A { x = 42, y = 420, z = 65 };
1084 auto rv1 = folly::tryTo<A>("1000000000000000000000000000000");
1085 EXPECT_FALSE(rv1.hasValue());
1086 auto rv2 = folly::tryTo<A>("42");
1087 EXPECT_TRUE(rv2.hasValue());
1088 EXPECT_EQ(A::x, rv2.value());
1089 auto rv3 = folly::tryTo<A>("50");
1090 EXPECT_TRUE(rv3.hasValue());
1091 EXPECT_EQ(static_cast<A>(50), rv3.value());
1094 TEST(Conv, TryStringToFloat) {
1095 auto rv1 = folly::tryTo<float>("");
1096 EXPECT_FALSE(rv1.hasValue());
1097 auto rv2 = folly::tryTo<float>("3.14");
1098 EXPECT_TRUE(rv2.hasValue());
1099 EXPECT_NEAR(rv2.value(), 3.14, 1e-5);
1102 TEST(Conv, TryStringToDouble) {
1103 auto rv1 = folly::tryTo<double>("");
1104 EXPECT_FALSE(rv1.hasValue());
1105 auto rv2 = folly::tryTo<double>("3.14");
1106 EXPECT_TRUE(rv2.hasValue());
1107 EXPECT_NEAR(rv2.value(), 3.14, 1e-10);
1110 TEST(Conv, TryIntToInt) {
1111 auto rv1 = folly::tryTo<uint8_t>(256);
1112 EXPECT_FALSE(rv1.hasValue());
1113 auto rv2 = folly::tryTo<uint8_t>(255);
1114 EXPECT_TRUE(rv2.hasValue());
1115 EXPECT_EQ(rv2.value(), 255);
1118 TEST(Conv, TryFloatToFloat) {
1119 auto rv1 = folly::tryTo<float>(1e100);
1120 EXPECT_FALSE(rv1.hasValue());
1121 auto rv2 = folly::tryTo<double>(25.5f);
1122 EXPECT_TRUE(rv2.hasValue());
1123 EXPECT_NEAR(rv2.value(), 25.5, 1e-10);
1126 TEST(Conv, TryFloatToInt) {
1127 auto rv1 = folly::tryTo<int>(100.001);
1128 EXPECT_FALSE(rv1.hasValue());
1129 auto rv2 = folly::tryTo<int>(100.0);
1130 EXPECT_TRUE(rv2.hasValue());
1131 EXPECT_EQ(rv2.value(), 100);
1134 TEST(Conv, TryIntToFloat) {
1135 auto rv1 = folly::tryTo<float>(std::numeric_limits<uint64_t>::max());
1136 EXPECT_FALSE(rv1.hasValue());
1137 auto rv2 = folly::tryTo<float>(1000ULL);
1138 EXPECT_TRUE(rv2.hasValue());
1139 EXPECT_EQ(rv2.value(), 1000.0f);
1142 TEST(Conv, TryPtrPairToInt) {
1143 StringPiece sp1("1000000000000000000000000000000");
1144 auto rv1 = folly::tryTo<int>(sp1.begin(), sp1.end());
1145 EXPECT_FALSE(rv1.hasValue());
1146 StringPiece sp2("4711");
1147 auto rv2 = folly::tryTo<int>(sp2.begin(), sp2.end());
1148 EXPECT_TRUE(rv2.hasValue());
1149 EXPECT_EQ(rv2.value(), 4711);
1150 StringPiece sp3("-4711");
1151 auto rv3 = folly::tryTo<int>(sp3.begin(), sp3.end());
1152 EXPECT_TRUE(rv3.hasValue());
1153 EXPECT_EQ(rv3.value(), -4711);
1154 StringPiece sp4("4711");
1155 auto rv4 = folly::tryTo<uint16_t>(sp4.begin(), sp4.end());
1156 EXPECT_TRUE(rv4.hasValue());
1157 EXPECT_EQ(rv4.value(), 4711);
1160 TEST(Conv, NewUint64ToString) {
1163 #define THE_GREAT_EXPECTATIONS(n, len) \
1165 EXPECT_EQ((len), uint64ToBufferUnsafe((n), buf)); \
1167 auto s = string(#n); \
1168 s = s.substr(0, s.size() - 2); \
1169 EXPECT_EQ(s, buf); \
1172 THE_GREAT_EXPECTATIONS(0UL, 1);
1173 THE_GREAT_EXPECTATIONS(1UL, 1);
1174 THE_GREAT_EXPECTATIONS(12UL, 2);
1175 THE_GREAT_EXPECTATIONS(123UL, 3);
1176 THE_GREAT_EXPECTATIONS(1234UL, 4);
1177 THE_GREAT_EXPECTATIONS(12345UL, 5);
1178 THE_GREAT_EXPECTATIONS(123456UL, 6);
1179 THE_GREAT_EXPECTATIONS(1234567UL, 7);
1180 THE_GREAT_EXPECTATIONS(12345678UL, 8);
1181 THE_GREAT_EXPECTATIONS(123456789UL, 9);
1182 THE_GREAT_EXPECTATIONS(1234567890UL, 10);
1183 THE_GREAT_EXPECTATIONS(12345678901UL, 11);
1184 THE_GREAT_EXPECTATIONS(123456789012UL, 12);
1185 THE_GREAT_EXPECTATIONS(1234567890123UL, 13);
1186 THE_GREAT_EXPECTATIONS(12345678901234UL, 14);
1187 THE_GREAT_EXPECTATIONS(123456789012345UL, 15);
1188 THE_GREAT_EXPECTATIONS(1234567890123456UL, 16);
1189 THE_GREAT_EXPECTATIONS(12345678901234567UL, 17);
1190 THE_GREAT_EXPECTATIONS(123456789012345678UL, 18);
1191 THE_GREAT_EXPECTATIONS(1234567890123456789UL, 19);
1192 THE_GREAT_EXPECTATIONS(18446744073709551614UL, 20);
1193 THE_GREAT_EXPECTATIONS(18446744073709551615UL, 20);
1195 #undef THE_GREAT_EXPECTATIONS
1198 TEST(Conv, allocate_size) {
1199 std::string str1 = "meh meh meh";
1200 std::string str2 = "zdech zdech zdech";
1202 auto res1 = folly::to<std::string>(str1, ".", str2);
1203 EXPECT_EQ(res1, str1 + "." + str2);
1205 std::string res2; //empty
1206 toAppendFit(str1, str2, 1, &res2);
1207 EXPECT_EQ(res2, str1 + str2 + "1");
1210 toAppendDelimFit(",", str1, str2, &res3);
1211 EXPECT_EQ(res3, str1 + "," + str2);
1217 std::tuple<const int&, const int&> tuple_view() const {
1220 bool operator==(const Dimensions& other) const {
1221 return this->tuple_view() == other.tuple_view();
1225 Expected<StringPiece, ConversionCode> parseTo(
1226 folly::StringPiece in,
1228 return parseTo(in, out.w)
1229 .then([](StringPiece sp) { return sp.removePrefix("x"), sp; })
1230 .then([&](StringPiece sp) { return parseTo(sp, out.h); });
1233 template <class String>
1234 void toAppend(const Dimensions& in, String* result) {
1235 folly::toAppend(in.w, 'x', in.h, result);
1238 size_t estimateSpaceNeeded(const Dimensions&in) {
1239 return 2000 + folly::estimateSpaceNeeded(in.w) +
1240 folly::estimateSpaceNeeded(in.h);
1244 TEST(Conv, custom_kkproviders) {
1245 my::Dimensions expected{7, 8};
1246 EXPECT_EQ(expected, folly::to<my::Dimensions>("7x8"));
1247 auto str = folly::to<std::string>(expected);
1248 EXPECT_EQ("7x8", str);
1249 // make sure above implementation of estimateSpaceNeeded() is used.
1250 EXPECT_GT(str.capacity(), 2000);
1251 EXPECT_LT(str.capacity(), 2500);
1254 TEST(Conv, TryToThenWithVoid) {
1255 auto x = tryTo<int>("42").then([](int) {});
1256 EXPECT_TRUE(x.hasValue());