/*
- * Copyright 2015 Facebook, Inc.
+ * Copyright 2017 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>
+#ifndef __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS 1
+#endif
+
#include <boost/lexical_cast.hpp>
-#include <gtest/gtest.h>
+
+#include <folly/Conv.h>
+#include <folly/container/Foreach.h>
+#include <folly/portability/GTest.h>
+
+#include <algorithm>
+#include <cinttypes>
#include <limits>
+#include <sstream>
#include <stdexcept>
+#include <tuple>
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, digits10Minimal) {
- // Not much of a test (and it's included in the test below anyway).
- // I just want to inspect the generated assembly for this function.
- folly::doNotOptimizeAway(digits10(random() * random()));
-}
TEST(Conv, digits10) {
char buffer[100];
// 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), "%lu", 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), "%lu", power);
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power);
EXPECT_EQ(strlen(buffer), digits10(power));
- snprintf(buffer, sizeof(buffer), "%lu", power - 1);
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power - 1);
EXPECT_EQ(strlen(buffer), digits10(power - 1));
- snprintf(buffer, sizeof(buffer), "%lu", 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), "%lu", power);
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power);
EXPECT_EQ(strlen(buffer), digits10(power));
- snprintf(buffer, sizeof(buffer), "%lu", power - 1);
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, power - 1);
EXPECT_EQ(strlen(buffer), digits10(power - 1));
- snprintf(buffer, sizeof(buffer), "%lu", 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;
+ float floatV = 4.2f;
EXPECT_EQ(to<float>(floatV), 4.2f);
double doubleV = 0.42;
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);
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();
}
TEST(Conv, Floating2Floating) {
- float f1 = 1e3;
+ float f1 = 1e3f;
double d1 = to<double>(f1);
EXPECT_EQ(f1, d1);
EXPECT_TRUE(shouldWork == std::numeric_limits<float>::min() ||
shouldWork == 0.f);
} catch (...) {
- EXPECT_TRUE(false);
+ ADD_FAILURE();
}
}
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
#endif
TEST(Conv, Integral2String) {
- testIntegral2String<std::string, char, short, int, long>();
- testIntegral2String<fbstring, char, short, int, long>();
+ testIntegral2String<std::string, int8_t, int16_t, int32_t, int64_t>();
+ testIntegral2String<fbstring, int8_t, int16_t, int32_t, int64_t>();
#if FOLLY_HAVE_INT128_T
test128Bit2String<std::string>();
}
TEST(Conv, String2Integral) {
- testString2Integral<const char*, signed char, short, int, long, long long>();
- testString2Integral<std::string, signed char, short, int, long, long long>();
- testString2Integral<fbstring, signed char, short, int, long, long long>();
+ testString2Integral<const char*, int8_t, int16_t, int32_t, int64_t>();
+ testString2Integral<std::string, int8_t, int16_t, int32_t, int64_t>();
+ testString2Integral<fbstring, int8_t, int16_t, int32_t, int64_t>();
// Testing the behavior of the StringPiece* API
// StringPiece* normally parses as much valid data as it can,
}
TEST(Conv, StringPieceToDouble) {
- string s = "2134123.125 zorro";
- StringPiece pc(s);
- EXPECT_EQ(to<double>(&pc), 2134123.125);
- EXPECT_EQ(pc, " zorro");
-
- EXPECT_THROW(to<double>(StringPiece(s)), std::range_error);
- EXPECT_EQ(to<double>(StringPiece(s.data(), pc.data())), 2134123.125);
+ vector<tuple<const char*, const char*, double>> strs{
+ make_tuple("2134123.125 zorro", " zorro", 2134123.125),
+ make_tuple(" 2134123.125 zorro", " zorro", 2134123.125),
+ make_tuple(" 2134123.125 zorro", " zorro", 2134123.125),
+ make_tuple(" 2134123.125 zorro ", " zorro ", 2134123.125),
+ make_tuple("2134123.125zorro", "zorro", 2134123.125),
+ make_tuple("0 zorro", " zorro", 0.0),
+ make_tuple(" 0 zorro", " zorro", 0.0),
+ make_tuple(" 0 zorro", " zorro", 0.0),
+ make_tuple(" 0 zorro ", " zorro ", 0.0),
+ make_tuple("0zorro", "zorro", 0.0),
+ make_tuple("0.0 zorro", " zorro", 0.0),
+ make_tuple(" 0.0 zorro", " zorro", 0.0),
+ make_tuple(" 0.0 zorro", " zorro", 0.0),
+ make_tuple(" 0.0 zorro ", " zorro ", 0.0),
+ make_tuple("0.0zorro", "zorro", 0.0),
+ };
+ for (const auto& s : strs) {
+ StringPiece pc(get<0>(s));
+ EXPECT_EQ(get<2>(s), to<double>(&pc)) << "\"" << get<0>(s) << "\"";
+ EXPECT_EQ(get<1>(s), pc);
+ EXPECT_THROW(to<double>(StringPiece(get<0>(s))), std::range_error);
+ EXPECT_EQ(get<2>(s), to<double>(StringPiece(get<0>(s), pc.data())));
+ }
-// Test NaN conversion
+ // Test NaN conversion
try {
to<double>("not a number");
- EXPECT_TRUE(false);
+ ADD_FAILURE();
} catch (const std::range_error &) {
}
+ EXPECT_TRUE(std::isnan(to<double>("nan")));
EXPECT_TRUE(std::isnan(to<double>("NaN")));
+ EXPECT_TRUE(std::isnan(to<double>("NAN")));
+ EXPECT_TRUE(std::isnan(to<double>("-nan")));
+ EXPECT_TRUE(std::isnan(to<double>("-NaN")));
+ EXPECT_TRUE(std::isnan(to<double>("-NAN")));
+
EXPECT_EQ(to<double>("inf"), numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("Inf"), numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("INF"), numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("inF"), numeric_limits<double>::infinity());
EXPECT_EQ(to<double>("infinity"), numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("Infinity"), numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("INFINITY"), numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("iNfInItY"), numeric_limits<double>::infinity());
EXPECT_THROW(to<double>("infinitX"), std::range_error);
EXPECT_EQ(to<double>("-inf"), -numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("-Inf"), -numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("-INF"), -numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("-inF"), -numeric_limits<double>::infinity());
EXPECT_EQ(to<double>("-infinity"), -numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("-Infinity"), -numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("-INFINITY"), -numeric_limits<double>::infinity());
+ EXPECT_EQ(to<double>("-iNfInItY"), -numeric_limits<double>::infinity());
EXPECT_THROW(to<double>("-infinitX"), std::range_error);
}
try {
to<int>(pc);
- EXPECT_TRUE(false);
+ ADD_FAILURE();
} catch (const std::range_error &) {
}
}
try {
to<int64_t>(&pc);
- EXPECT_TRUE(false);
+ ADD_FAILURE();
} catch (const std::range_error &) {
}
}
try {
to<double>(pc);
- EXPECT_TRUE(false);
+ ADD_FAILURE();
} catch (const std::range_error &) {
}
}
/* This seems not work in ubuntu11.10, gcc 4.6.1
try {
auto f = to<float>(957837589847);
- EXPECT_TRUE(false);
+ ADD_FAILURE();
} catch (std::range_error& e) {
//LOG(INFO) << e.what();
}
auto i = to<int>(42.0);
EXPECT_EQ(i, 42);
try {
- auto i = to<int>(42.1);
- EXPECT_TRUE(false);
- } catch (std::range_error& e) {
+ auto i2 = to<int>(42.1);
+ LOG(ERROR) << "to<int> returned " << i2 << " instead of throwing";
+ ADD_FAILURE();
+ } catch (std::range_error&) {
//LOG(INFO) << e.what();
}
}
auto j = to<char>(x);
EXPECT_EQ(j, 42);
try {
- auto i = to<char>(y);
- LOG(ERROR) << static_cast<unsigned int>(i);
- EXPECT_TRUE(false);
- } catch (std::range_error& e) {
+ auto i2 = to<char>(y);
+ LOG(ERROR) << "to<char> returned "
+ << static_cast<unsigned int>(i2)
+ << " instead of throwing";
+ ADD_FAILURE();
+ } catch (std::range_error&) {
//LOG(INFO) << e.what();
}
}
auto j = to<A>(100);
EXPECT_EQ(j, 100);
try {
- auto i = to<A>(5000000000L);
- EXPECT_TRUE(false);
- } catch (std::range_error& e) {
+ auto i2 = to<A>(5000000000L);
+ LOG(ERROR) << "to<A> returned "
+ << static_cast<unsigned int>(i2)
+ << " instead of throwing";
+ ADD_FAILURE();
+ } catch (std::range_error&) {
//LOG(INFO) << e.what();
}
}
EXPECT_EQ(e, x);
try {
auto i = to<int32_t>(x);
- LOG(ERROR) << to<uint32_t>(x);
- EXPECT_TRUE(false);
- } catch (std::range_error& e) {
+ LOG(ERROR) << "to<int32_t> returned " << i << " instead of throwing";
+ ADD_FAILURE();
+ } catch (std::range_error&) {
}
}
-#if defined(__clang__) || __GNUC_PREREQ(4, 7)
-// to<enum class> and to(enum class) only supported in gcc 4.7 onwards
-
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);
- auto s = to<string>(E::x);
- EXPECT_EQ("3000000000", s);
- auto e = to<E>(3000000000U);
- EXPECT_EQ(e, E::x);
- try {
- auto i = to<int32_t>(E::x);
- LOG(ERROR) << to<uint32_t>(E::x);
- EXPECT_TRUE(false);
- } catch (std::range_error& e) {
- }
+ EXPECT_EQ("3000000000", to<string>(E::x));
+ EXPECT_EQ(E::x, to<E>(3000000000U));
+ EXPECT_EQ(E::x, to<E>("3000000000"));
+ E e;
+ EXPECT_TRUE(parseTo("3000000000", e).hasValue());
+ 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
EXPECT_EQ("foo.65", to<string>("foo.", A::z));
}
-#endif // gcc 4.7 onwards
+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>
+template <typename Src>
void testStr2Bool() {
EXPECT_FALSE(to<bool>(Src("0")));
EXPECT_FALSE(to<bool>(Src(" 000 ")));
EXPECT_EQ(buf5, sp5.begin());
}
+TEST(Conv, Transform) {
+ const std::vector<int64_t> in{1, 2, 3};
+ std::vector<std::string> out(in.size());
+ std::transform(in.begin(), in.end(), out.begin(), to<std::string, int64_t>);
+ const std::vector<std::string> ref{"1", "2", "3"};
+ EXPECT_EQ(ref, out);
+}
+
+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);
+ EXPECT_EQ(to<bool>(2.7), true);
+ EXPECT_EQ(to<bool>(std::numeric_limits<double>::max()), true);
+ EXPECT_EQ(to<bool>(std::numeric_limits<double>::min()), true);
+ EXPECT_EQ(to<bool>(std::numeric_limits<double>::lowest()), true);
+ EXPECT_EQ(to<bool>(std::numeric_limits<double>::quiet_NaN()), true);
+ EXPECT_EQ(to<bool>(std::numeric_limits<double>::infinity()), true);
+ EXPECT_EQ(to<bool>(-std::numeric_limits<double>::infinity()), true);
+}
+
+namespace {
+
+template <typename F>
+void testConvError(
+ F&& expr,
+ const char* exprStr,
+ ConversionCode code,
+ const char* value,
+ bool quotedValue,
+ int line) {
+ std::string where = to<std::string>(__FILE__, "(", line, "): ");
+ try {
+ auto res = expr();
+ ADD_FAILURE() << where << exprStr << " -> " << res;
+ } catch (const ConversionError& e) {
+ EXPECT_EQ(code, e.errorCode()) << where << exprStr;
+ std::string str(e.what());
+ EXPECT_FALSE(str.empty()) << where << exprStr << " -> " << str;
+ auto pos = str.find(':');
+ if (value) {
+ std::ostringstream exp;
+ exp << str.substr(0, pos) + ": ";
+ if (quotedValue) {
+ exp << "\"" << value << "\"";
+ } else {
+ exp << value;
+ }
+ EXPECT_EQ(exp.str(), str) << where << exprStr << " -> " << str;
+ } else {
+ EXPECT_EQ(pos, std::string::npos) << where << exprStr << " -> " << str;
+ }
+ }
+}
+} // namespace
+
+#define EXPECT_CONV_ERROR_QUOTE(expr, code, value, quoted) \
+ testConvError( \
+ [&] { return expr; }, \
+ #expr, \
+ ConversionCode::code, \
+ value, \
+ quoted, \
+ __LINE__)
+
+#define EXPECT_CONV_ERROR(expr, code, value) \
+ EXPECT_CONV_ERROR_QUOTE(expr, code, value, true)
+
+#define EXPECT_CONV_ERROR_STR(type, str, code) \
+ EXPECT_CONV_ERROR(to<type>(str), code, str)
+
+#define EXPECT_CONV_ERROR_STR_NOVAL(type, str, code) \
+ EXPECT_CONV_ERROR(to<type>(str), code, nullptr)
+
+TEST(Conv, ConversionErrorStrToBool) {
+ EXPECT_CONV_ERROR_STR_NOVAL(bool, StringPiece(), EMPTY_INPUT_STRING);
+ EXPECT_CONV_ERROR_STR_NOVAL(bool, "", EMPTY_INPUT_STRING);
+ EXPECT_CONV_ERROR_STR(bool, " ", EMPTY_INPUT_STRING);
+ EXPECT_CONV_ERROR_STR(bool, " 11 ", BOOL_OVERFLOW);
+ EXPECT_CONV_ERROR_STR(bool, "other ", BOOL_INVALID_VALUE);
+ EXPECT_CONV_ERROR_STR(bool, " bla", BOOL_INVALID_VALUE);
+ EXPECT_CONV_ERROR(to<bool>(" offbla"), NON_WHITESPACE_AFTER_END, "bla");
+}
+
+TEST(Conv, ConversionErrorStrToFloat) {
+ EXPECT_CONV_ERROR_STR_NOVAL(float, StringPiece(), EMPTY_INPUT_STRING);
+ EXPECT_CONV_ERROR_STR_NOVAL(float, "", EMPTY_INPUT_STRING);
+ EXPECT_CONV_ERROR_STR(float, " ", EMPTY_INPUT_STRING);
+ EXPECT_CONV_ERROR_STR(float, " junk", STRING_TO_FLOAT_ERROR);
+ EXPECT_CONV_ERROR(to<float>(" 1bla"), NON_WHITESPACE_AFTER_END, "bla");
+}
+
+TEST(Conv, ConversionErrorStrToInt) {
+ // empty string handling
+ EXPECT_CONV_ERROR_STR_NOVAL(int, StringPiece(), EMPTY_INPUT_STRING);
+ EXPECT_CONV_ERROR_STR_NOVAL(int, "", EMPTY_INPUT_STRING);
+ EXPECT_CONV_ERROR_STR(int, " ", EMPTY_INPUT_STRING);
+
+ // signed integers
+ EXPECT_CONV_ERROR_STR(int, " *", INVALID_LEADING_CHAR);
+ EXPECT_CONV_ERROR_STR(int, " +", NO_DIGITS);
+ EXPECT_CONV_ERROR_STR(int, " +*", NON_DIGIT_CHAR);
+ EXPECT_CONV_ERROR_STR(int8_t, " 128", POSITIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_STR(int8_t, " -129", NEGATIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_STR(int8_t, " 1000", POSITIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_STR(int8_t, "-1000", NEGATIVE_OVERFLOW);
+ EXPECT_CONV_ERROR(to<int>(" -13bla"), NON_WHITESPACE_AFTER_END, "bla");
+
+ // unsigned integers
+ EXPECT_CONV_ERROR_STR(unsigned, " -", NON_DIGIT_CHAR);
+ EXPECT_CONV_ERROR_STR(uint8_t, " 256", POSITIVE_OVERFLOW);
+ EXPECT_CONV_ERROR(to<unsigned>("42bla"), NON_WHITESPACE_AFTER_END, "bla");
+}
+
+#define EXPECT_CONV_ERROR_PP_VAL(type, str, code, val) \
+ do { \
+ StringPiece input(str); \
+ EXPECT_CONV_ERROR(to<type>(input.begin(), input.end()), code, val); \
+ } while (0)
+
+#define EXPECT_CONV_ERROR_PP(type, str, code) \
+ EXPECT_CONV_ERROR_PP_VAL(type, str, code, str)
+
+TEST(Conv, ConversionErrorPtrPairToInt) {
+ // signed integers
+ EXPECT_CONV_ERROR_PP(int, "", INVALID_LEADING_CHAR);
+ EXPECT_CONV_ERROR_PP(int, " ", INVALID_LEADING_CHAR);
+ EXPECT_CONV_ERROR_PP(int, "*", INVALID_LEADING_CHAR);
+ EXPECT_CONV_ERROR_PP(int, "+", NO_DIGITS);
+ EXPECT_CONV_ERROR_PP(int8_t, "128", POSITIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_PP(int8_t, "-129", NEGATIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_PP(int8_t, "1000", POSITIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_PP(int8_t, "-1000", NEGATIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_PP(int, "-junk", NON_DIGIT_CHAR);
+
+ // unsigned integers
+ EXPECT_CONV_ERROR_PP(unsigned, "", NO_DIGITS);
+ EXPECT_CONV_ERROR_PP(uint8_t, "256", POSITIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_PP(unsigned, "junk", NON_DIGIT_CHAR);
+}
+
+namespace {
+
+template <typename T, typename V>
+std::string prefixWithType(V value) {
+ std::ostringstream oss;
+#ifdef FOLLY_HAS_RTTI
+ oss << "(" << demangle(typeid(T)) << ") ";
+#endif
+ oss << to<std::string>(value);
+ return oss.str();
+}
+} // namespace
+
+#define EXPECT_CONV_ERROR_ARITH(type, val, code) \
+ EXPECT_CONV_ERROR_QUOTE( \
+ to<type>(val), code, prefixWithType<type>(val).c_str(), false)
+
+TEST(Conv, ConversionErrorIntToInt) {
+ EXPECT_CONV_ERROR_ARITH(signed char, 128, ARITH_POSITIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_ARITH(unsigned char, -1, ARITH_NEGATIVE_OVERFLOW);
+}
+
+TEST(Conv, ConversionErrorFloatToFloat) {
+ EXPECT_CONV_ERROR_ARITH(
+ float, std::numeric_limits<double>::max(), ARITH_POSITIVE_OVERFLOW);
+ EXPECT_CONV_ERROR_ARITH(
+ float, std::numeric_limits<double>::lowest(), ARITH_NEGATIVE_OVERFLOW);
+}
+
+TEST(Conv, ConversionErrorIntToFloat) {
+ EXPECT_CONV_ERROR_ARITH(
+ float, std::numeric_limits<long long>::max(), ARITH_LOSS_OF_PRECISION);
+}
+
+TEST(Conv, ConversionErrorFloatToInt) {
+ EXPECT_CONV_ERROR_ARITH(int8_t, 65.5, ARITH_LOSS_OF_PRECISION);
+}
+
+TEST(Conv, TryStringToBool) {
+ auto rv1 = folly::tryTo<bool>("xxxx");
+ EXPECT_FALSE(rv1.hasValue());
+ auto rv2 = folly::tryTo<bool>("false");
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_FALSE(rv2.value());
+ auto rv3 = folly::tryTo<bool>("yes");
+ EXPECT_TRUE(rv3.hasValue());
+ EXPECT_TRUE(rv3.value());
+}
+
+TEST(Conv, TryStringToInt) {
+ auto rv1 = folly::tryTo<int>("1000000000000000000000000000000");
+ EXPECT_FALSE(rv1.hasValue());
+ auto rv2 = folly::tryTo<int>("4711");
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_EQ(rv2.value(), 4711);
+}
+
+TEST(Conv, TryStringToEnum) {
+ enum class A { x = 42, y = 420, z = 65 };
+ auto rv1 = folly::tryTo<A>("1000000000000000000000000000000");
+ EXPECT_FALSE(rv1.hasValue());
+ auto rv2 = folly::tryTo<A>("42");
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_EQ(A::x, rv2.value());
+ auto rv3 = folly::tryTo<A>("50");
+ EXPECT_TRUE(rv3.hasValue());
+ EXPECT_EQ(static_cast<A>(50), rv3.value());
+}
+
+TEST(Conv, TryStringToFloat) {
+ auto rv1 = folly::tryTo<float>("");
+ EXPECT_FALSE(rv1.hasValue());
+ auto rv2 = folly::tryTo<float>("3.14");
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_NEAR(rv2.value(), 3.14, 1e-5);
+}
+
+TEST(Conv, TryStringToDouble) {
+ auto rv1 = folly::tryTo<double>("");
+ EXPECT_FALSE(rv1.hasValue());
+ auto rv2 = folly::tryTo<double>("3.14");
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_NEAR(rv2.value(), 3.14, 1e-10);
+}
+
+TEST(Conv, TryIntToInt) {
+ auto rv1 = folly::tryTo<uint8_t>(256);
+ EXPECT_FALSE(rv1.hasValue());
+ auto rv2 = folly::tryTo<uint8_t>(255);
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_EQ(rv2.value(), 255);
+}
+
+TEST(Conv, TryFloatToFloat) {
+ auto rv1 = folly::tryTo<float>(1e100);
+ EXPECT_FALSE(rv1.hasValue());
+ auto rv2 = folly::tryTo<double>(25.5f);
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_NEAR(rv2.value(), 25.5, 1e-10);
+}
+
+TEST(Conv, TryFloatToInt) {
+ auto rv1 = folly::tryTo<int>(100.001);
+ EXPECT_FALSE(rv1.hasValue());
+ auto rv2 = folly::tryTo<int>(100.0);
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_EQ(rv2.value(), 100);
+}
+
+TEST(Conv, TryIntToFloat) {
+ auto rv1 = folly::tryTo<float>(std::numeric_limits<uint64_t>::max());
+ EXPECT_FALSE(rv1.hasValue());
+ auto rv2 = folly::tryTo<float>(1000ULL);
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_EQ(rv2.value(), 1000.0f);
+}
+
+TEST(Conv, TryPtrPairToInt) {
+ StringPiece sp1("1000000000000000000000000000000");
+ auto rv1 = folly::tryTo<int>(sp1.begin(), sp1.end());
+ EXPECT_FALSE(rv1.hasValue());
+ StringPiece sp2("4711");
+ auto rv2 = folly::tryTo<int>(sp2.begin(), sp2.end());
+ EXPECT_TRUE(rv2.hasValue());
+ EXPECT_EQ(rv2.value(), 4711);
+ StringPiece sp3("-4711");
+ auto rv3 = folly::tryTo<int>(sp3.begin(), sp3.end());
+ EXPECT_TRUE(rv3.hasValue());
+ EXPECT_EQ(rv3.value(), -4711);
+ StringPiece sp4("4711");
+ auto rv4 = folly::tryTo<uint16_t>(sp4.begin(), sp4.end());
+ EXPECT_TRUE(rv4.hasValue());
+ EXPECT_EQ(rv4.value(), 4711);
+}
+
TEST(Conv, NewUint64ToString) {
char buf[21];
EXPECT_EQ(res3, str1 + "," + str2);
}
-////////////////////////////////////////////////////////////////////////////////
-// 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");
+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:;
- }
-
- 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;
-}
-
-static StringPiece pc1 = "1234567890123456789";
-
-void handwrittenAtoiMeasure(unsigned int n, unsigned int digits) {
- auto p = pc1.subpiece(pc1.size() - digits, digits);
- FOR_EACH_RANGE (i, 0, n) {
- doNotOptimizeAway(handwrittenAtoi(p.begin(), p.end()));
- }
-}
-
-void follyAtoiMeasure(unsigned int n, unsigned int 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(unsigned int n, unsigned int 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()));
- }
-}
-
-void clibStrtoulMeasure(unsigned int n, unsigned int 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));
+ bool operator==(const Dimensions& other) const {
+ return this->tuple_view() == other.tuple_view();
}
-}
-
-void lexicalCastMeasure(unsigned int n, unsigned int 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()));
- }
-}
-
-// Benchmarks for unsigned to string conversion, raw
-
-unsigned u64ToAsciiTable(uint64_t value, char* dst) {
- static const char digits[201] =
- "00010203040506070809"
- "10111213141516171819"
- "20212223242526272829"
- "30313233343536373839"
- "40414243444546474849"
- "50515253545556575859"
- "60616263646566676869"
- "70717273747576777879"
- "80818283848586878889"
- "90919293949596979899";
-
- uint32_t const length = digits10(value);
- uint32_t next = length - 1;
- while (value >= 100) {
- auto const i = (value % 100) * 2;
- value /= 100;
- dst[next] = digits[i + 1];
- dst[next - 1] = digits[i];
- next -= 2;
- }
- // Handle last 1-2 digits
- if (value < 10) {
- dst[next] = '0' + uint32_t(value);
- } else {
- auto i = uint32_t(value) * 2;
- dst[next] = digits[i + 1];
- dst[next - 1] = digits[i];
- }
- return length;
-}
-
-void u64ToAsciiTableBM(unsigned int n, uint64_t value) {
- // This is too fast, need to do 10 times per iteration
- char buf[20];
- FOR_EACH_RANGE (i, 0, n) {
- doNotOptimizeAway(u64ToAsciiTable(value + n, buf));
- }
-}
-
-unsigned u64ToAsciiClassic(uint64_t value, char* dst) {
- // Write backwards.
- char* next = (char*)dst;
- char* start = next;
- do {
- *next++ = '0' + (value % 10);
- value /= 10;
- } while (value != 0);
- unsigned length = next - start;
-
- // Reverse in-place.
- next--;
- while (next > start) {
- char swap = *next;
- *next = *start;
- *start = swap;
- next--;
- start++;
- }
- return length;
-}
-
-void u64ToAsciiClassicBM(unsigned int n, uint64_t value) {
- // This is too fast, need to do 10 times per iteration
- char buf[20];
- FOR_EACH_RANGE (i, 0, n) {
- doNotOptimizeAway(u64ToAsciiClassic(value + n, buf));
- }
-}
+};
-void u64ToAsciiFollyBM(unsigned int n, uint64_t value) {
- // This is too fast, need to do 10 times per iteration
- char buf[20];
- FOR_EACH_RANGE (i, 0, n) {
- doNotOptimizeAway(uint64ToBufferUnsafe(value + n, buf));
- }
+Expected<StringPiece, ConversionCode> parseTo(
+ folly::StringPiece in,
+ Dimensions& out) {
+ return parseTo(in, out.w)
+ .then([](StringPiece sp) { return sp.removePrefix("x"), sp; })
+ .then([&](StringPiece sp) { return parseTo(sp, out.h); });
}
-// Benchmark uitoa with string append
-
-void u2aAppendClassicBM(unsigned int n, uint64_t value) {
- string s;
- FOR_EACH_RANGE (i, 0, n) {
- // auto buf = &s.back() + 1;
- char buffer[20];
- s.append(buffer, u64ToAsciiClassic(value, buffer));
- doNotOptimizeAway(s.size());
- }
+template <class String>
+void toAppend(const Dimensions& in, String* result) {
+ folly::toAppend(in.w, 'x', in.h, result);
}
-void u2aAppendFollyBM(unsigned int n, uint64_t value) {
- string s;
- FOR_EACH_RANGE (i, 0, n) {
- // auto buf = &s.back() + 1;
- char buffer[20];
- s.append(buffer, uint64ToBufferUnsafe(value, buffer));
- doNotOptimizeAway(s.size());
- }
+size_t estimateSpaceNeeded(const Dimensions&in) {
+ return 2000 + folly::estimateSpaceNeeded(in.w) +
+ folly::estimateSpaceNeeded(in.h);
}
-
-template <class String>
-struct StringIdenticalToBM {
- StringIdenticalToBM() {}
- void operator()(unsigned int n, size_t len) const {
- String s;
- BENCHMARK_SUSPEND { s.append(len, '0'); }
- FOR_EACH_RANGE (i, 0, n) {
- String result = to<String>(s);
- doNotOptimizeAway(result.size());
- }
- }
-};
-
-template <class String>
-struct StringVariadicToBM {
- StringVariadicToBM() {}
- void operator()(unsigned int n, size_t len) const {
- String s;
- BENCHMARK_SUSPEND { s.append(len, '0'); }
- FOR_EACH_RANGE (i, 0, n) {
- String result = to<String>(s, nullptr);
- doNotOptimizeAway(result.size());
- }
- }
-};
-
-static size_t bigInt = 11424545345345;
-static size_t smallInt = 104;
-static char someString[] = "this is some nice string";
-static char otherString[] = "this is a long string, so it's not so nice";
-static char reallyShort[] = "meh";
-static std::string stdString = "std::strings are very nice";
-static float fValue = 1.2355;
-static double dValue = 345345345.435;
-
-BENCHMARK(preallocateTestNoFloat, n) {
- for (size_t i = 0; i < n; ++i) {
- auto val1 = to<std::string>(bigInt, someString, stdString, otherString);
- auto val3 = to<std::string>(reallyShort, smallInt);
- auto val2 = to<std::string>(bigInt, stdString);
- auto val4 = to<std::string>(bigInt, stdString, dValue, otherString);
- auto val5 = to<std::string>(bigInt, someString, reallyShort);
- }
+} // namespace my
+
+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);
}
-BENCHMARK(preallocateTestFloat, n) {
- for (size_t i = 0; i < n; ++i) {
- auto val1 = to<std::string>(stdString, ',', fValue, dValue);
- auto val2 = to<std::string>(stdString, ',', dValue);
- }
-}
-BENCHMARK_DRAW_LINE();
-
-static const StringIdenticalToBM<std::string> stringIdenticalToBM;
-static const StringVariadicToBM<std::string> stringVariadicToBM;
-static const StringIdenticalToBM<fbstring> fbstringIdenticalToBM;
-static const StringVariadicToBM<fbstring> fbstringVariadicToBM;
-
-#define DEFINE_BENCHMARK_GROUP(n) \
- BENCHMARK_PARAM(u64ToAsciiClassicBM, n); \
- BENCHMARK_RELATIVE_PARAM(u64ToAsciiTableBM, n); \
- BENCHMARK_RELATIVE_PARAM(u64ToAsciiFollyBM, n); \
- BENCHMARK_DRAW_LINE();
-
-DEFINE_BENCHMARK_GROUP(1);
-DEFINE_BENCHMARK_GROUP(12);
-DEFINE_BENCHMARK_GROUP(123);
-DEFINE_BENCHMARK_GROUP(1234);
-DEFINE_BENCHMARK_GROUP(12345);
-DEFINE_BENCHMARK_GROUP(123456);
-DEFINE_BENCHMARK_GROUP(1234567);
-DEFINE_BENCHMARK_GROUP(12345678);
-DEFINE_BENCHMARK_GROUP(123456789);
-DEFINE_BENCHMARK_GROUP(1234567890);
-DEFINE_BENCHMARK_GROUP(12345678901);
-DEFINE_BENCHMARK_GROUP(123456789012);
-DEFINE_BENCHMARK_GROUP(1234567890123);
-DEFINE_BENCHMARK_GROUP(12345678901234);
-DEFINE_BENCHMARK_GROUP(123456789012345);
-DEFINE_BENCHMARK_GROUP(1234567890123456);
-DEFINE_BENCHMARK_GROUP(12345678901234567);
-DEFINE_BENCHMARK_GROUP(123456789012345678);
-DEFINE_BENCHMARK_GROUP(1234567890123456789);
-DEFINE_BENCHMARK_GROUP(12345678901234567890U);
-
-#undef DEFINE_BENCHMARK_GROUP
-
-#define DEFINE_BENCHMARK_GROUP(n) \
- BENCHMARK_PARAM(clibAtoiMeasure, n); \
- BENCHMARK_RELATIVE_PARAM(lexicalCastMeasure, n); \
- BENCHMARK_RELATIVE_PARAM(handwrittenAtoiMeasure, n); \
- BENCHMARK_RELATIVE_PARAM(follyAtoiMeasure, n); \
- BENCHMARK_DRAW_LINE();
-
-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
-
-#define DEFINE_BENCHMARK_GROUP(T, n) \
- BENCHMARK_PARAM(T ## VariadicToBM, n); \
- BENCHMARK_RELATIVE_PARAM(T ## IdenticalToBM, n); \
- BENCHMARK_DRAW_LINE();
-
-DEFINE_BENCHMARK_GROUP(string, 32);
-DEFINE_BENCHMARK_GROUP(string, 1024);
-DEFINE_BENCHMARK_GROUP(string, 32768);
-DEFINE_BENCHMARK_GROUP(fbstring, 32);
-DEFINE_BENCHMARK_GROUP(fbstring, 1024);
-DEFINE_BENCHMARK_GROUP(fbstring, 32768);
-
-#undef DEFINE_BENCHMARK_GROUP
-
-int main(int argc, char** argv) {
- testing::InitGoogleTest(&argc, argv);
- gflags::ParseCommandLineFlags(&argc, &argv, true);
- auto ret = RUN_ALL_TESTS();
- if (!ret && FLAGS_benchmark) {
- folly::runBenchmarks();
- }
- return ret;
+TEST(Conv, TryToThenWithVoid) {
+ auto x = tryTo<int>("42").then([](int) {});
+ EXPECT_TRUE(x.hasValue());
+ Unit u = x.value();
+ (void)u;
}
projects / folly.git / blobdiff