/*
- * Copyright 2012 Facebook, Inc.
+ * Copyright 2016 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* limitations under the License.
*/
-#include "folly/Benchmark.h"
-#include "folly/Conv.h"
-#include "folly/Foreach.h"
+#include <folly/Conv.h>
+#include <folly/Foreach.h>
#include <boost/lexical_cast.hpp>
#include <gtest/gtest.h>
#include <limits>
using namespace std;
using namespace folly;
-static int8_t s8;
-static uint8_t u8;
-static int16_t s16;
-static uint16_t u16;
-static int32_t s32;
-static uint32_t u32;
-static int64_t s64;
-static uint64_t u64;
+
+TEST(Conv, digits10) {
+ char buffer[100];
+ uint64_t power;
+
+ // first, some basic sniff tests
+ EXPECT_EQ( 1, digits10(0));
+ EXPECT_EQ( 1, digits10(1));
+ EXPECT_EQ( 1, digits10(9));
+ EXPECT_EQ( 2, digits10(10));
+ EXPECT_EQ( 2, digits10(99));
+ EXPECT_EQ( 3, digits10(100));
+ EXPECT_EQ( 3, digits10(999));
+ EXPECT_EQ( 4, digits10(1000));
+ EXPECT_EQ( 4, digits10(9999));
+ EXPECT_EQ(20, digits10(18446744073709551615ULL));
+
+ // try the first X nonnegatives.
+ // Covers some more cases of 2^p, 10^p
+ for (uint64_t i = 0; i < 100000; i++) {
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, i);
+ EXPECT_EQ(strlen(buffer), digits10(i));
+ }
+
+ // try powers of 2
+ power = 1;
+ for (int p = 0; p < 64; p++) {
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power);
+ EXPECT_EQ(strlen(buffer), digits10(power));
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power - 1);
+ EXPECT_EQ(strlen(buffer), digits10(power - 1));
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power + 1);
+ EXPECT_EQ(strlen(buffer), digits10(power + 1));
+ power *= 2;
+ }
+
+ // try powers of 10
+ power = 1;
+ for (int p = 0; p < 20; p++) {
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power);
+ EXPECT_EQ(strlen(buffer), digits10(power));
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power - 1);
+ EXPECT_EQ(strlen(buffer), digits10(power - 1));
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power + 1);
+ EXPECT_EQ(strlen(buffer), digits10(power + 1));
+ power *= 10;
+ }
+}
+
+// Test to<T>(T)
+TEST(Conv, Type2Type) {
+ bool boolV = true;
+ EXPECT_EQ(to<bool>(boolV), true);
+
+ int intV = 42;
+ EXPECT_EQ(to<int>(intV), 42);
+
+ float floatV = 4.2;
+ EXPECT_EQ(to<float>(floatV), 4.2f);
+
+ double doubleV = 0.42;
+ EXPECT_EQ(to<double>(doubleV), 0.42);
+
+ std::string stringV = "StdString";
+ EXPECT_EQ(to<std::string>(stringV), "StdString");
+
+ folly::fbstring fbStrV = "FBString";
+ EXPECT_EQ(to<folly::fbstring>(fbStrV), "FBString");
+
+ folly::StringPiece spV("StringPiece");
+ EXPECT_EQ(to<folly::StringPiece>(spV), "StringPiece");
+
+ // Rvalues
+ EXPECT_EQ(to<bool>(true), true);
+ EXPECT_EQ(to<int>(42), 42);
+ EXPECT_EQ(to<float>(4.2f), 4.2f);
+ EXPECT_EQ(to<double>(.42), .42);
+ EXPECT_EQ(to<std::string>(std::string("Hello")), "Hello");
+ EXPECT_EQ(to<folly::fbstring>(folly::fbstring("hello")), "hello");
+ EXPECT_EQ(to<folly::StringPiece>(folly::StringPiece("Forty Two")),
+ "Forty Two");
+}
TEST(Conv, Integral2Integral) {
// Same size, different signs
- s64 = numeric_limits<uint8_t>::max();
+ int64_t s64 = numeric_limits<uint8_t>::max();
EXPECT_EQ(to<uint8_t>(s64), s64);
s64 = numeric_limits<int8_t>::max();
testIntegral2String<String, Ints...>();
}
+#if FOLLY_HAVE_INT128_T
+template <class String>
+void test128Bit2String() {
+ typedef unsigned __int128 Uint;
+ typedef __int128 Sint;
+
+ EXPECT_EQ(detail::digitsEnough<unsigned __int128>(), 39);
+
+ Uint value = 123;
+ EXPECT_EQ(to<String>(value), "123");
+ Sint svalue = 123;
+ EXPECT_EQ(to<String>(svalue), "123");
+ svalue = -123;
+ EXPECT_EQ(to<String>(svalue), "-123");
+
+ value = __int128(1) << 64;
+ EXPECT_EQ(to<String>(value), "18446744073709551616");
+
+ svalue = -(__int128(1) << 64);
+ EXPECT_EQ(to<String>(svalue), "-18446744073709551616");
+
+ value = 0;
+ EXPECT_EQ(to<String>(value), "0");
+
+ svalue = 0;
+ EXPECT_EQ(to<String>(svalue), "0");
+
+ value = ~__int128(0);
+ EXPECT_EQ(to<String>(value), "340282366920938463463374607431768211455");
+
+ svalue = -(Uint(1) << 127);
+ EXPECT_EQ(to<String>(svalue), "-170141183460469231731687303715884105728");
+
+ svalue = (Uint(1) << 127) - 1;
+ EXPECT_EQ(to<String>(svalue), "170141183460469231731687303715884105727");
+
+ // TODO: the following do not compile to<__int128> ...
+
+#if 0
+ value = numeric_limits<Uint>::min();
+ EXPECT_EQ(to<Uint>(to<String>(value)), value);
+ value = numeric_limits<Uint>::max();
+ EXPECT_EQ(to<Uint>(to<String>(value)), value);
+
+ svalue = numeric_limits<Sint>::min();
+ EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
+ value = numeric_limits<Sint>::max();
+ EXPECT_EQ(to<Sint>(to<String>(svalue)), svalue);
+#endif
+}
+
+#endif
+
TEST(Conv, Integral2String) {
testIntegral2String<std::string, char, short, int, long>();
testIntegral2String<fbstring, char, short, int, long>();
+
+#if FOLLY_HAVE_INT128_T
+ test128Bit2String<std::string>();
+ test128Bit2String<fbstring>();
+#endif
}
template <class String>
}
}
+template <class String>
+void testIdenticalTo() {
+ String s("Yukkuri shiteitte ne!!!");
+
+ String result = to<String>(s);
+ EXPECT_EQ(result, s);
+}
+
template <class String>
void testVariadicTo() {
String s;
EXPECT_EQ(s, "Lorem ipsum 1234 dolor amet 567.89.");
}
+template <class String>
+void testIdenticalToDelim() {
+ String s("Yukkuri shiteitte ne!!!");
+
+ String charDelim = toDelim<String>('$', s);
+ EXPECT_EQ(charDelim, s);
+
+ String strDelim = toDelim<String>(String(">_<"), s);
+ EXPECT_EQ(strDelim, s);
+}
+
+template <class String>
+void testVariadicToDelim() {
+ String s;
+ toAppendDelim(":", &s);
+ toAppendDelim(
+ ":", "Lorem ipsum ", 1234, String(" dolor amet "), 567.89, '!', &s);
+ EXPECT_EQ(s, "Lorem ipsum :1234: dolor amet :567.89:!");
+
+ s = toDelim<String>(':');
+ EXPECT_TRUE(s.empty());
+
+ s = toDelim<String>(
+ ":", "Lorem ipsum ", nullptr, 1234, " dolor amet ", 567.89, '.');
+ EXPECT_EQ(s, "Lorem ipsum ::1234: dolor amet :567.89:.");
+}
+
TEST(Conv, NullString) {
- string s1 = to<string>((char *) NULL);
+ string s1 = to<string>((char *) nullptr);
EXPECT_TRUE(s1.empty());
- fbstring s2 = to<fbstring>((char *) NULL);
+ fbstring s2 = to<fbstring>((char *) nullptr);
EXPECT_TRUE(s2.empty());
}
TEST(Conv, VariadicTo) {
+ testIdenticalTo<string>();
+ testIdenticalTo<fbstring>();
testVariadicTo<string>();
testVariadicTo<fbstring>();
}
+TEST(Conv, VariadicToDelim) {
+ testIdenticalToDelim<string>();
+ testIdenticalToDelim<fbstring>();
+ testVariadicToDelim<string>();
+ testVariadicToDelim<fbstring>();
+}
+
template <class String>
void testDoubleToString() {
EXPECT_EQ(to<string>(0.0), "0");
EXPECT_EQ(i, 42);
try {
auto i = to<int>(42.1);
+ LOG(ERROR) << "to<int> returned " << i << " instead of throwing";
EXPECT_TRUE(false);
} catch (std::range_error& e) {
//LOG(INFO) << e.what();
EXPECT_EQ(j, 42);
try {
auto i = to<char>(y);
- LOG(ERROR) << static_cast<unsigned int>(i);
+ LOG(ERROR) << "to<char> returned "
+ << static_cast<unsigned int>(i)
+ << " instead of throwing";
EXPECT_TRUE(false);
} catch (std::range_error& e) {
//LOG(INFO) << e.what();
TEST(Conv, IntToEnum) {
enum A { x = 42, y = 420 };
auto i = to<A>(42);
- EXPECT_EQ(i, A::x);
+ EXPECT_EQ(i, x);
auto j = to<A>(100);
EXPECT_EQ(j, 100);
try {
auto i = to<A>(5000000000L);
+ LOG(ERROR) << "to<A> returned "
+ << static_cast<unsigned int>(i)
+ << " instead of throwing";
EXPECT_TRUE(false);
} catch (std::range_error& e) {
//LOG(INFO) << e.what();
}
}
+TEST(Conv, UnsignedEnum) {
+ enum E : uint32_t { x = 3000000000U };
+ auto u = to<uint32_t>(x);
+ EXPECT_EQ(u, 3000000000U);
+ auto s = to<string>(x);
+ EXPECT_EQ("3000000000", s);
+ auto e = to<E>(3000000000U);
+ EXPECT_EQ(e, x);
+ try {
+ auto i = to<int32_t>(x);
+ LOG(ERROR) << "to<int32_t> returned " << i << " instead of throwing";
+ EXPECT_TRUE(false);
+ } catch (std::range_error& e) {
+ }
+}
+
+TEST(Conv, UnsignedEnumClass) {
+ enum class E : uint32_t { x = 3000000000U };
+ auto u = to<uint32_t>(E::x);
+ EXPECT_GT(u, 0);
+ EXPECT_EQ(u, 3000000000U);
+ EXPECT_EQ("3000000000", to<string>(E::x));
+ EXPECT_EQ(E::x, to<E>(3000000000U));
+ EXPECT_EQ(E::x, to<E>("3000000000"));
+ E e;
+ parseTo("3000000000", e);
+ EXPECT_EQ(E::x, e);
+ EXPECT_THROW(to<int32_t>(E::x), std::range_error);
+}
+
+// Multi-argument to<string> uses toAppend, a different code path than
+// to<string>(enum).
+TEST(Conv, EnumClassToString) {
+ enum class A { x = 4, y = 420, z = 65 };
+ EXPECT_EQ("foo.4", to<string>("foo.", A::x));
+ EXPECT_EQ("foo.420", to<string>("foo.", A::y));
+ EXPECT_EQ("foo.65", to<string>("foo.", A::z));
+}
+
+TEST(Conv, IntegralToBool) {
+ EXPECT_FALSE(to<bool>(0));
+ EXPECT_FALSE(to<bool>(0ul));
+
+ EXPECT_TRUE(to<bool>(1));
+ EXPECT_TRUE(to<bool>(1ul));
+
+ EXPECT_TRUE(to<bool>(-42));
+ EXPECT_TRUE(to<bool>(42ul));
+}
+
template<typename Src>
void testStr2Bool() {
EXPECT_FALSE(to<bool>(Src("0")));
EXPECT_EQ(buf5, sp5.begin());
}
-////////////////////////////////////////////////////////////////////////////////
-// Benchmarks for ASCII to int conversion
-////////////////////////////////////////////////////////////////////////////////
-// @author: Rajat Goel (rajat)
-
-static int64_t handwrittenAtoi(const char* start, const char* end) {
-
- bool positive = true;
- int64_t retVal = 0;
-
- if (start == end) {
- throw std::runtime_error("empty string");
+TEST(Conv, FloatToInt) {
+ EXPECT_EQ(to<int>(42.0f), 42);
+ EXPECT_EQ(to<int8_t>(-128.0f), int8_t(-128));
+ EXPECT_THROW(to<int8_t>(-129.0), std::range_error);
+ EXPECT_THROW(to<int8_t>(127.001), std::range_error);
+ EXPECT_THROW(to<uint8_t>(-0.0001), std::range_error);
+ EXPECT_THROW(
+ to<uint64_t>(static_cast<float>(std::numeric_limits<uint64_t>::max())),
+ std::range_error);
+}
+
+TEST(Conv, IntToFloat) {
+ EXPECT_EQ(to<float>(42ULL), 42.0);
+ EXPECT_EQ(to<float>(int8_t(-128)), -128.0);
+ EXPECT_THROW(
+ to<float>(std::numeric_limits<uint64_t>::max()), std::range_error);
+ EXPECT_THROW(
+ to<float>(std::numeric_limits<int64_t>::max()), std::range_error);
+ EXPECT_THROW(
+ to<float>(std::numeric_limits<int64_t>::min() + 1), std::range_error);
+#if FOLLY_HAVE_INT128_T
+ EXPECT_THROW(
+ to<double>(std::numeric_limits<unsigned __int128>::max()),
+ std::range_error);
+ EXPECT_THROW(
+ to<double>(std::numeric_limits<__int128>::max()), std::range_error);
+ EXPECT_THROW(
+ to<double>(std::numeric_limits<__int128>::min() + 1), std::range_error);
+#endif
+}
+
+TEST(Conv, BoolToFloat) {
+ EXPECT_EQ(to<double>(true), 1.0);
+ EXPECT_EQ(to<double>(false), 0.0);
+}
+
+TEST(Conv, FloatToBool) {
+ EXPECT_EQ(to<bool>(1.0), true);
+ EXPECT_EQ(to<bool>(0.0), false);
+}
+
+TEST(Conv, NewUint64ToString) {
+ char buf[21];
+
+#define THE_GREAT_EXPECTATIONS(n, len) \
+ do { \
+ EXPECT_EQ((len), uint64ToBufferUnsafe((n), buf)); \
+ buf[(len)] = 0; \
+ auto s = string(#n); \
+ s = s.substr(0, s.size() - 2); \
+ EXPECT_EQ(s, buf); \
+ } while (0)
+
+ THE_GREAT_EXPECTATIONS(0UL, 1);
+ THE_GREAT_EXPECTATIONS(1UL, 1);
+ THE_GREAT_EXPECTATIONS(12UL, 2);
+ THE_GREAT_EXPECTATIONS(123UL, 3);
+ THE_GREAT_EXPECTATIONS(1234UL, 4);
+ THE_GREAT_EXPECTATIONS(12345UL, 5);
+ THE_GREAT_EXPECTATIONS(123456UL, 6);
+ THE_GREAT_EXPECTATIONS(1234567UL, 7);
+ THE_GREAT_EXPECTATIONS(12345678UL, 8);
+ THE_GREAT_EXPECTATIONS(123456789UL, 9);
+ THE_GREAT_EXPECTATIONS(1234567890UL, 10);
+ THE_GREAT_EXPECTATIONS(12345678901UL, 11);
+ THE_GREAT_EXPECTATIONS(123456789012UL, 12);
+ THE_GREAT_EXPECTATIONS(1234567890123UL, 13);
+ THE_GREAT_EXPECTATIONS(12345678901234UL, 14);
+ THE_GREAT_EXPECTATIONS(123456789012345UL, 15);
+ THE_GREAT_EXPECTATIONS(1234567890123456UL, 16);
+ THE_GREAT_EXPECTATIONS(12345678901234567UL, 17);
+ THE_GREAT_EXPECTATIONS(123456789012345678UL, 18);
+ THE_GREAT_EXPECTATIONS(1234567890123456789UL, 19);
+ THE_GREAT_EXPECTATIONS(18446744073709551614UL, 20);
+ THE_GREAT_EXPECTATIONS(18446744073709551615UL, 20);
+
+#undef THE_GREAT_EXPECTATIONS
+}
+
+TEST(Conv, allocate_size) {
+ std::string str1 = "meh meh meh";
+ std::string str2 = "zdech zdech zdech";
+
+ auto res1 = folly::to<std::string>(str1, ".", str2);
+ EXPECT_EQ(res1, str1 + "." + str2);
+
+ std::string res2; //empty
+ toAppendFit(str1, str2, 1, &res2);
+ EXPECT_EQ(res2, str1 + str2 + "1");
+
+ std::string res3;
+ toAppendDelimFit(",", str1, str2, &res3);
+ EXPECT_EQ(res3, str1 + "," + str2);
+}
+
+namespace my {
+struct Dimensions {
+ int w, h;
+ std::tuple<const int&, const int&> tuple_view() const {
+ return tie(w, h);
}
-
- while (start < end && isspace(*start)) {
- ++start;
- }
-
- switch (*start) {
- case '-':
- positive = false;
- case '+':
- ++start;
- default:;
+ bool operator==(const Dimensions& other) const {
+ return this->tuple_view() == other.tuple_view();
}
+};
- while (start < end && *start >= '0' && *start <= '9') {
- auto const newRetVal = retVal * 10 + (*start++ - '0');
- if (newRetVal < retVal) {
- throw std::runtime_error("overflow");
- }
- retVal = newRetVal;
- }
-
- if (start != end) {
- throw std::runtime_error("extra chars at the end");
- }
-
- return positive ? retVal : -retVal;
+void parseTo(folly::StringPiece in, Dimensions& out) {
+ out.w = folly::to<int>(&in);
+ in.removePrefix("x");
+ out.h = folly::to<int>(&in);
}
-static StringPiece pc1 = "1234567890123456789";
-
-void handwrittenAtoiMeasure(uint n, uint digits) {
- auto p = pc1.subpiece(pc1.size() - digits, digits);
- FOR_EACH_RANGE (i, 0, n) {
- doNotOptimizeAway(handwrittenAtoi(p.begin(), p.end()));
- }
-}
-
-void follyAtoiMeasure(uint n, uint digits) {
- auto p = pc1.subpiece(pc1.size() - digits, digits);
- FOR_EACH_RANGE (i, 0, n) {
- doNotOptimizeAway(folly::to<int64_t>(p.begin(), p.end()));
- }
-}
-
-void clibAtoiMeasure(uint n, uint digits) {
- auto p = pc1.subpiece(pc1.size() - digits, digits);
- assert(*p.end() == 0);
- static_assert(sizeof(long) == 8, "64-bit long assumed");
- FOR_EACH_RANGE (i, 0, n) {
- doNotOptimizeAway(atol(p.begin()));
- }
+template <class String>
+void toAppend(const Dimensions& in, String* result) {
+ folly::toAppend(in.w, 'x', in.h, result);
}
-void clibStrtoulMeasure(uint n, uint digits) {
- auto p = pc1.subpiece(pc1.size() - digits, digits);
- assert(*p.end() == 0);
- char * endptr;
- FOR_EACH_RANGE (i, 0, n) {
- doNotOptimizeAway(strtoul(p.begin(), &endptr, 10));
- }
+size_t estimateSpaceNeeded(const Dimensions&in) {
+ return 2000 + folly::estimateSpaceNeeded(in.w) +
+ folly::estimateSpaceNeeded(in.h);
}
-
-void lexicalCastMeasure(uint n, uint digits) {
- auto p = pc1.subpiece(pc1.size() - digits, digits);
- assert(*p.end() == 0);
- FOR_EACH_RANGE (i, 0, n) {
- doNotOptimizeAway(boost::lexical_cast<uint64_t>(p.begin()));
- }
}
-#define DEFINE_BENCHMARK_GROUP(n) \
- BENCHMARK_PARAM(clibAtoiMeasure, n); \
- BENCHMARK_RELATIVE_PARAM(lexicalCastMeasure, n); \
- BENCHMARK_RELATIVE_PARAM(handwrittenAtoiMeasure, n); \
- BENCHMARK_RELATIVE_PARAM(follyAtoiMeasure, n);
-
-DEFINE_BENCHMARK_GROUP(1);
-DEFINE_BENCHMARK_GROUP(2);
-DEFINE_BENCHMARK_GROUP(3);
-DEFINE_BENCHMARK_GROUP(4);
-DEFINE_BENCHMARK_GROUP(5);
-DEFINE_BENCHMARK_GROUP(6);
-DEFINE_BENCHMARK_GROUP(7);
-DEFINE_BENCHMARK_GROUP(8);
-DEFINE_BENCHMARK_GROUP(9);
-DEFINE_BENCHMARK_GROUP(10);
-DEFINE_BENCHMARK_GROUP(11);
-DEFINE_BENCHMARK_GROUP(12);
-DEFINE_BENCHMARK_GROUP(13);
-DEFINE_BENCHMARK_GROUP(14);
-DEFINE_BENCHMARK_GROUP(15);
-DEFINE_BENCHMARK_GROUP(16);
-DEFINE_BENCHMARK_GROUP(17);
-DEFINE_BENCHMARK_GROUP(18);
-DEFINE_BENCHMARK_GROUP(19);
-
-#undef DEFINE_BENCHMARK_GROUP
-
-int main(int argc, char** argv) {
- testing::InitGoogleTest(&argc, argv);
- google::ParseCommandLineFlags(&argc, &argv, true);
- auto ret = RUN_ALL_TESTS();
- if (!ret && FLAGS_benchmark) {
- folly::runBenchmarks();
- }
- return ret;
+TEST(Conv, custom_kkproviders) {
+ my::Dimensions expected{7, 8};
+ EXPECT_EQ(expected, folly::to<my::Dimensions>("7x8"));
+ auto str = folly::to<std::string>(expected);
+ EXPECT_EQ("7x8", str);
+ // make sure above implementation of estimateSpaceNeeded() is used.
+ EXPECT_GT(str.capacity(), 2000);
+ EXPECT_LT(str.capacity(), 2500);
}
projects / folly.git / blobdiff