/*
- * Copyright 2013 Facebook, Inc.
+ * Copyright 2014 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
}
} // namespace
+struct PrettyTestCase{
+ std::string prettyString;
+ double realValue;
+ PrettyType prettyType;
+};
-TEST(PrettyPrint, Basic) {
- // check time printing
- EXPECT_EQ(string("8.53e+07 s "), prettyPrint(85.3e6, PRETTY_TIME));
- EXPECT_EQ(string("85.3 s "), prettyPrint(85.3, PRETTY_TIME));
- EXPECT_EQ(string("85.3 ms"), prettyPrint(85.3e-3, PRETTY_TIME));
- EXPECT_EQ(string("85.3 us"), prettyPrint(85.3e-6, PRETTY_TIME));
- EXPECT_EQ(string("85.3 ns"), prettyPrint(85.3e-9, PRETTY_TIME));
- EXPECT_EQ(string("85.3 ps"), prettyPrint(85.3e-12, PRETTY_TIME));
- EXPECT_EQ(string("8.53e-14 s "), prettyPrint(85.3e-15, PRETTY_TIME));
-
- EXPECT_EQ(string("0 s "), prettyPrint(0, PRETTY_TIME));
- EXPECT_EQ(string("1 s "), prettyPrint(1.0, PRETTY_TIME));
- EXPECT_EQ(string("1 ms"), prettyPrint(1.0e-3, PRETTY_TIME));
- EXPECT_EQ(string("1 us"), prettyPrint(1.0e-6, PRETTY_TIME));
- EXPECT_EQ(string("1 ns"), prettyPrint(1.0e-9, PRETTY_TIME));
- EXPECT_EQ(string("1 ps"), prettyPrint(1.0e-12, PRETTY_TIME));
+PrettyTestCase prettyTestCases[] =
+{
+ {string("8.53e+07 s "), 85.3e6, PRETTY_TIME},
+ {string("8.53e+07 s "), 85.3e6, PRETTY_TIME},
+ {string("85.3 ms"), 85.3e-3, PRETTY_TIME},
+ {string("85.3 us"), 85.3e-6, PRETTY_TIME},
+ {string("85.3 ns"), 85.3e-9, PRETTY_TIME},
+ {string("85.3 ps"), 85.3e-12, PRETTY_TIME},
+ {string("8.53e-14 s "), 85.3e-15, PRETTY_TIME},
+
+ {string("0 s "), 0, PRETTY_TIME},
+ {string("1 s "), 1.0, PRETTY_TIME},
+ {string("1 ms"), 1.0e-3, PRETTY_TIME},
+ {string("1 us"), 1.0e-6, PRETTY_TIME},
+ {string("1 ns"), 1.0e-9, PRETTY_TIME},
+ {string("1 ps"), 1.0e-12, PRETTY_TIME},
// check bytes printing
- EXPECT_EQ(string("853 B "), prettyPrint(853., PRETTY_BYTES));
- EXPECT_EQ(string("833 kB"), prettyPrint(853.e3, PRETTY_BYTES));
- EXPECT_EQ(string("813.5 MB"), prettyPrint(853.e6, PRETTY_BYTES));
- EXPECT_EQ(string("7.944 GB"), prettyPrint(8.53e9, PRETTY_BYTES));
- EXPECT_EQ(string("794.4 GB"), prettyPrint(853.e9, PRETTY_BYTES));
- EXPECT_EQ(string("775.8 TB"), prettyPrint(853.e12, PRETTY_BYTES));
-
- EXPECT_EQ(string("0 B "), prettyPrint(0, PRETTY_BYTES));
- EXPECT_EQ(string("1 B "), prettyPrint(pow2(0), PRETTY_BYTES));
- EXPECT_EQ(string("1 kB"), prettyPrint(pow2(10), PRETTY_BYTES));
- EXPECT_EQ(string("1 MB"), prettyPrint(pow2(20), PRETTY_BYTES));
- EXPECT_EQ(string("1 GB"), prettyPrint(pow2(30), PRETTY_BYTES));
- EXPECT_EQ(string("1 TB"), prettyPrint(pow2(40), PRETTY_BYTES));
-
- EXPECT_EQ(string("853 B "), prettyPrint(853., PRETTY_BYTES_IEC));
- EXPECT_EQ(string("833 KiB"), prettyPrint(853.e3, PRETTY_BYTES_IEC));
- EXPECT_EQ(string("813.5 MiB"), prettyPrint(853.e6, PRETTY_BYTES_IEC));
- EXPECT_EQ(string("7.944 GiB"), prettyPrint(8.53e9, PRETTY_BYTES_IEC));
- EXPECT_EQ(string("794.4 GiB"), prettyPrint(853.e9, PRETTY_BYTES_IEC));
- EXPECT_EQ(string("775.8 TiB"), prettyPrint(853.e12, PRETTY_BYTES_IEC));
-
- EXPECT_EQ(string("0 B "), prettyPrint(0, PRETTY_BYTES_IEC));
- EXPECT_EQ(string("1 B "), prettyPrint(pow2(0), PRETTY_BYTES_IEC));
- EXPECT_EQ(string("1 KiB"), prettyPrint(pow2(10), PRETTY_BYTES_IEC));
- EXPECT_EQ(string("1 MiB"), prettyPrint(pow2(20), PRETTY_BYTES_IEC));
- EXPECT_EQ(string("1 GiB"), prettyPrint(pow2(30), PRETTY_BYTES_IEC));
- EXPECT_EQ(string("1 TiB"), prettyPrint(pow2(40), PRETTY_BYTES_IEC));
+ {string("853 B "), 853., PRETTY_BYTES},
+ {string("833 kB"), 853.e3, PRETTY_BYTES},
+ {string("813.5 MB"), 853.e6, PRETTY_BYTES},
+ {string("7.944 GB"), 8.53e9, PRETTY_BYTES},
+ {string("794.4 GB"), 853.e9, PRETTY_BYTES},
+ {string("775.8 TB"), 853.e12, PRETTY_BYTES},
+
+ {string("0 B "), 0, PRETTY_BYTES},
+ {string("1 B "), pow2(0), PRETTY_BYTES},
+ {string("1 kB"), pow2(10), PRETTY_BYTES},
+ {string("1 MB"), pow2(20), PRETTY_BYTES},
+ {string("1 GB"), pow2(30), PRETTY_BYTES},
+ {string("1 TB"), pow2(40), PRETTY_BYTES},
+
+ {string("853 B "), 853., PRETTY_BYTES_IEC},
+ {string("833 KiB"), 853.e3, PRETTY_BYTES_IEC},
+ {string("813.5 MiB"), 853.e6, PRETTY_BYTES_IEC},
+ {string("7.944 GiB"), 8.53e9, PRETTY_BYTES_IEC},
+ {string("794.4 GiB"), 853.e9, PRETTY_BYTES_IEC},
+ {string("775.8 TiB"), 853.e12, PRETTY_BYTES_IEC},
+
+ {string("0 B "), 0, PRETTY_BYTES_IEC},
+ {string("1 B "), pow2(0), PRETTY_BYTES_IEC},
+ {string("1 KiB"), pow2(10), PRETTY_BYTES_IEC},
+ {string("1 MiB"), pow2(20), PRETTY_BYTES_IEC},
+ {string("1 GiB"), pow2(30), PRETTY_BYTES_IEC},
+ {string("1 TiB"), pow2(40), PRETTY_BYTES_IEC},
// check bytes metric printing
- EXPECT_EQ(string("853 B "), prettyPrint(853., PRETTY_BYTES_METRIC));
- EXPECT_EQ(string("853 kB"), prettyPrint(853.e3, PRETTY_BYTES_METRIC));
- EXPECT_EQ(string("853 MB"), prettyPrint(853.e6, PRETTY_BYTES_METRIC));
- EXPECT_EQ(string("8.53 GB"), prettyPrint(8.53e9, PRETTY_BYTES_METRIC));
- EXPECT_EQ(string("853 GB"), prettyPrint(853.e9, PRETTY_BYTES_METRIC));
- EXPECT_EQ(string("853 TB"), prettyPrint(853.e12, PRETTY_BYTES_METRIC));
+ {string("853 B "), 853., PRETTY_BYTES_METRIC},
+ {string("853 kB"), 853.e3, PRETTY_BYTES_METRIC},
+ {string("853 MB"), 853.e6, PRETTY_BYTES_METRIC},
+ {string("8.53 GB"), 8.53e9, PRETTY_BYTES_METRIC},
+ {string("853 GB"), 853.e9, PRETTY_BYTES_METRIC},
+ {string("853 TB"), 853.e12, PRETTY_BYTES_METRIC},
- EXPECT_EQ(string("0 B "), prettyPrint(0, PRETTY_BYTES_METRIC));
- EXPECT_EQ(string("1 B "), prettyPrint(1.0, PRETTY_BYTES_METRIC));
- EXPECT_EQ(string("1 kB"), prettyPrint(1.0e+3, PRETTY_BYTES_METRIC));
- EXPECT_EQ(string("1 MB"), prettyPrint(1.0e+6, PRETTY_BYTES_METRIC));
+ {string("0 B "), 0, PRETTY_BYTES_METRIC},
+ {string("1 B "), 1.0, PRETTY_BYTES_METRIC},
+ {string("1 kB"), 1.0e+3, PRETTY_BYTES_METRIC},
+ {string("1 MB"), 1.0e+6, PRETTY_BYTES_METRIC},
- EXPECT_EQ(string("1 GB"), prettyPrint(1.0e+9, PRETTY_BYTES_METRIC));
- EXPECT_EQ(string("1 TB"), prettyPrint(1.0e+12, PRETTY_BYTES_METRIC));
+ {string("1 GB"), 1.0e+9, PRETTY_BYTES_METRIC},
+ {string("1 TB"), 1.0e+12, PRETTY_BYTES_METRIC},
// check metric-units (powers of 1000) printing
- EXPECT_EQ(string("853 "), prettyPrint(853., PRETTY_UNITS_METRIC));
- EXPECT_EQ(string("853 k"), prettyPrint(853.e3, PRETTY_UNITS_METRIC));
- EXPECT_EQ(string("853 M"), prettyPrint(853.e6, PRETTY_UNITS_METRIC));
- EXPECT_EQ(string("8.53 bil"), prettyPrint(8.53e9, PRETTY_UNITS_METRIC));
- EXPECT_EQ(string("853 bil"), prettyPrint(853.e9, PRETTY_UNITS_METRIC));
- EXPECT_EQ(string("853 tril"), prettyPrint(853.e12, PRETTY_UNITS_METRIC));
+ {string("853 "), 853., PRETTY_UNITS_METRIC},
+ {string("853 k"), 853.e3, PRETTY_UNITS_METRIC},
+ {string("853 M"), 853.e6, PRETTY_UNITS_METRIC},
+ {string("8.53 bil"), 8.53e9, PRETTY_UNITS_METRIC},
+ {string("853 bil"), 853.e9, PRETTY_UNITS_METRIC},
+ {string("853 tril"), 853.e12, PRETTY_UNITS_METRIC},
// check binary-units (powers of 1024) printing
- EXPECT_EQ(string("0 "), prettyPrint(0, PRETTY_UNITS_BINARY));
- EXPECT_EQ(string("1 "), prettyPrint(pow2(0), PRETTY_UNITS_BINARY));
- EXPECT_EQ(string("1 k"), prettyPrint(pow2(10), PRETTY_UNITS_BINARY));
- EXPECT_EQ(string("1 M"), prettyPrint(pow2(20), PRETTY_UNITS_BINARY));
- EXPECT_EQ(string("1 G"), prettyPrint(pow2(30), PRETTY_UNITS_BINARY));
- EXPECT_EQ(string("1 T"), prettyPrint(pow2(40), PRETTY_UNITS_BINARY));
-
- EXPECT_EQ(string("1023 "),
- prettyPrint(pow2(10) - 1, PRETTY_UNITS_BINARY));
- EXPECT_EQ(string("1024 k"),
- prettyPrint(pow2(20) - 1, PRETTY_UNITS_BINARY));
- EXPECT_EQ(string("1024 M"),
- prettyPrint(pow2(30) - 1, PRETTY_UNITS_BINARY));
- EXPECT_EQ(string("1024 G"),
- prettyPrint(pow2(40) - 1, PRETTY_UNITS_BINARY));
-
- EXPECT_EQ(string("0 "), prettyPrint(0, PRETTY_UNITS_BINARY_IEC));
- EXPECT_EQ(string("1 "), prettyPrint(pow2(0), PRETTY_UNITS_BINARY_IEC));
- EXPECT_EQ(string("1 Ki"), prettyPrint(pow2(10), PRETTY_UNITS_BINARY_IEC));
- EXPECT_EQ(string("1 Mi"), prettyPrint(pow2(20), PRETTY_UNITS_BINARY_IEC));
- EXPECT_EQ(string("1 Gi"), prettyPrint(pow2(30), PRETTY_UNITS_BINARY_IEC));
- EXPECT_EQ(string("1 Ti"), prettyPrint(pow2(40), PRETTY_UNITS_BINARY_IEC));
-
- EXPECT_EQ(string("1023 "),
- prettyPrint(pow2(10) - 1, PRETTY_UNITS_BINARY_IEC));
- EXPECT_EQ(string("1024 Ki"),
- prettyPrint(pow2(20) - 1, PRETTY_UNITS_BINARY_IEC));
- EXPECT_EQ(string("1024 Mi"),
- prettyPrint(pow2(30) - 1, PRETTY_UNITS_BINARY_IEC));
- EXPECT_EQ(string("1024 Gi"),
- prettyPrint(pow2(40) - 1, PRETTY_UNITS_BINARY_IEC));
+ {string("0 "), 0, PRETTY_UNITS_BINARY},
+ {string("1 "), pow2(0), PRETTY_UNITS_BINARY},
+ {string("1 k"), pow2(10), PRETTY_UNITS_BINARY},
+ {string("1 M"), pow2(20), PRETTY_UNITS_BINARY},
+ {string("1 G"), pow2(30), PRETTY_UNITS_BINARY},
+ {string("1 T"), pow2(40), PRETTY_UNITS_BINARY},
+
+ {string("1023 "), pow2(10) - 1, PRETTY_UNITS_BINARY},
+ {string("1024 k"), pow2(20) - 1, PRETTY_UNITS_BINARY},
+ {string("1024 M"), pow2(30) - 1, PRETTY_UNITS_BINARY},
+ {string("1024 G"), pow2(40) - 1, PRETTY_UNITS_BINARY},
+
+ {string("0 "), 0, PRETTY_UNITS_BINARY_IEC},
+ {string("1 "), pow2(0), PRETTY_UNITS_BINARY_IEC},
+ {string("1 Ki"), pow2(10), PRETTY_UNITS_BINARY_IEC},
+ {string("1 Mi"), pow2(20), PRETTY_UNITS_BINARY_IEC},
+ {string("1 Gi"), pow2(30), PRETTY_UNITS_BINARY_IEC},
+ {string("1 Ti"), pow2(40), PRETTY_UNITS_BINARY_IEC},
+
+ {string("1023 "), pow2(10) - 1, PRETTY_UNITS_BINARY_IEC},
+ {string("1024 Ki"), pow2(20) - 1, PRETTY_UNITS_BINARY_IEC},
+ {string("1024 Mi"), pow2(30) - 1, PRETTY_UNITS_BINARY_IEC},
+ {string("1024 Gi"), pow2(40) - 1, PRETTY_UNITS_BINARY_IEC},
+
+ //check border SI cases
+
+ {string("1 Y"), 1e24, PRETTY_SI},
+ {string("10 Y"), 1e25, PRETTY_SI},
+ {string("1 y"), 1e-24, PRETTY_SI},
+ {string("10 y"), 1e-23, PRETTY_SI},
// check that negative values work
- EXPECT_EQ(string("-85.3 s "), prettyPrint(-85.3, PRETTY_TIME));
- EXPECT_EQ(string("-85.3 ms"), prettyPrint(-85.3e-3, PRETTY_TIME));
- EXPECT_EQ(string("-85.3 us"), prettyPrint(-85.3e-6, PRETTY_TIME));
- EXPECT_EQ(string("-85.3 ns"), prettyPrint(-85.3e-9, PRETTY_TIME));
+ {string("-85.3 s "), -85.3, PRETTY_TIME},
+ {string("-85.3 ms"), -85.3e-3, PRETTY_TIME},
+ {string("-85.3 us"), -85.3e-6, PRETTY_TIME},
+ {string("-85.3 ns"), -85.3e-9, PRETTY_TIME},
+ // end of test
+ {string("endoftest"), 0, PRETTY_NUM_TYPES}
+};
+
+TEST(PrettyPrint, Basic) {
+ for (int i = 0; prettyTestCases[i].prettyType != PRETTY_NUM_TYPES; ++i){
+ const PrettyTestCase& prettyTest = prettyTestCases[i];
+ EXPECT_EQ(prettyTest.prettyString,
+ prettyPrint(prettyTest.realValue, prettyTest.prettyType));
+ }
+}
+
+TEST(PrettyToDouble, Basic) {
+ // check manually created tests
+ for (int i = 0; prettyTestCases[i].prettyType != PRETTY_NUM_TYPES; ++i){
+ PrettyTestCase testCase = prettyTestCases[i];
+ PrettyType formatType = testCase.prettyType;
+ double x = testCase.realValue;
+ std::string testString = testCase.prettyString;
+ double recoveredX;
+ try{
+ recoveredX = prettyToDouble(testString, formatType);
+ } catch (std::range_error &ex){
+ EXPECT_TRUE(false);
+ }
+ double relativeError = fabs(x) < 1e-5 ? (x-recoveredX) :
+ (x - recoveredX) / x;
+ EXPECT_NEAR(0, relativeError, 1e-3);
+ }
+
+ // checks for compatibility with prettyPrint over the whole parameter space
+ for (int i = 0 ; i < PRETTY_NUM_TYPES; ++i){
+ PrettyType formatType = static_cast<PrettyType>(i);
+ for (double x = 1e-18; x < 1e40; x *= 1.9){
+ bool addSpace = static_cast<PrettyType> (i) == PRETTY_SI;
+ for (int it = 0; it < 2; ++it, addSpace = true){
+ double recoveredX;
+ try{
+ recoveredX = prettyToDouble(prettyPrint(x, formatType, addSpace),
+ formatType);
+ } catch (std::range_error &ex){
+ EXPECT_TRUE(false);
+ }
+ double relativeError = (x - recoveredX) / x;
+ EXPECT_NEAR(0, relativeError, 1e-3);
+ }
+ }
+ }
+
+ // check for incorrect values
+ EXPECT_THROW(prettyToDouble("10Mx", PRETTY_SI), std::range_error);
+ EXPECT_THROW(prettyToDouble("10 Mx", PRETTY_SI), std::range_error);
+ EXPECT_THROW(prettyToDouble("10 M x", PRETTY_SI), std::range_error);
+
+ StringPiece testString = "10Mx";
+ EXPECT_DOUBLE_EQ(prettyToDouble(&testString, PRETTY_UNITS_METRIC), 10e6);
+ EXPECT_EQ(testString, "x");
}
TEST(PrettyPrint, HexDump) {
};
} // namespace folly_test
+#if FOLLY_HAVE_CPLUS_DEMANGLE_V3_CALLBACK
TEST(System, demangle) {
- EXPECT_EQ("folly_test::ThisIsAVeryLongStructureName",
- demangle(typeid(folly_test::ThisIsAVeryLongStructureName)));
+ char expected[] = "folly_test::ThisIsAVeryLongStructureName";
+ EXPECT_STREQ(
+ expected,
+ demangle(typeid(folly_test::ThisIsAVeryLongStructureName)).c_str());
+
+ {
+ char buf[sizeof(expected)];
+ EXPECT_EQ(sizeof(expected) - 1,
+ demangle(typeid(folly_test::ThisIsAVeryLongStructureName),
+ buf, sizeof(buf)));
+ EXPECT_STREQ(expected, buf);
+
+ EXPECT_EQ(sizeof(expected) - 1,
+ demangle(typeid(folly_test::ThisIsAVeryLongStructureName),
+ buf, 11));
+ EXPECT_STREQ("folly_test", buf);
+ }
}
+#endif
namespace {
EXPECT_EQ(parts[2], "c");
parts.clear();
+ folly::split(',', StringPiece("a,b,c"), parts);
+ EXPECT_EQ(parts.size(), 3);
+ EXPECT_EQ(parts[0], "a");
+ EXPECT_EQ(parts[1], "b");
+ EXPECT_EQ(parts[2], "c");
+ parts.clear();
+
folly::split(',', string("a,b,c"), parts);
EXPECT_EQ(parts.size(), 3);
EXPECT_EQ(parts[0], "a");
EXPECT_EQ(parts[0], "");
parts.clear();
+ folly::split("a", StringPiece(), parts, true);
+ EXPECT_EQ(parts.size(), 0);
+ parts.clear();
+
+ folly::split("a", StringPiece(), parts);
+ EXPECT_EQ(parts.size(), 1);
+ EXPECT_EQ(parts[0], "");
+ parts.clear();
+
folly::split("a", "abcdefg", parts, true);
EXPECT_EQ(parts.size(), 1);
EXPECT_EQ(parts[0], "bcdefg");
parts.clear();
- orig = "All, , your bases, are , , belong to us";
+ orig = "All, , your base, are , , belong to us";
folly::split(", ", orig, parts, true);
EXPECT_EQ(parts.size(), 4);
EXPECT_EQ(parts[0], "All");
- EXPECT_EQ(parts[1], "your bases");
+ EXPECT_EQ(parts[1], "your base");
EXPECT_EQ(parts[2], "are ");
EXPECT_EQ(parts[3], "belong to us");
parts.clear();
EXPECT_EQ(parts.size(), 6);
EXPECT_EQ(parts[0], "All");
EXPECT_EQ(parts[1], "");
- EXPECT_EQ(parts[2], "your bases");
+ EXPECT_EQ(parts[2], "your base");
EXPECT_EQ(parts[3], "are ");
EXPECT_EQ(parts[4], "");
EXPECT_EQ(parts[5], "belong to us");
EXPECT_EQ(pieces[0], "bcdefg");
pieces.clear();
- orig = "All, , your bases, are , , belong to us";
+ orig = "All, , your base, are , , belong to us";
folly::split(", ", orig, pieces, true);
EXPECT_EQ(pieces.size(), 4);
EXPECT_EQ(pieces[0], "All");
- EXPECT_EQ(pieces[1], "your bases");
+ EXPECT_EQ(pieces[1], "your base");
EXPECT_EQ(pieces[2], "are ");
EXPECT_EQ(pieces[3], "belong to us");
pieces.clear();
EXPECT_EQ(pieces.size(), 6);
EXPECT_EQ(pieces[0], "All");
EXPECT_EQ(pieces[1], "");
- EXPECT_EQ(pieces[2], "your bases");
+ EXPECT_EQ(pieces[2], "your base");
EXPECT_EQ(pieces[3], "are ");
EXPECT_EQ(pieces[4], "");
EXPECT_EQ(pieces[5], "belong to us");
EXPECT_FALSE(folly::split('.', "a.b", a));
}
+TEST(Split, fixed_convert) {
+ StringPiece a, d;
+ int b;
+ double c;
+
+ EXPECT_TRUE(folly::split(':', "a:13:14.7:b", a, b, c, d));
+ EXPECT_EQ("a", a);
+ EXPECT_EQ(13, b);
+ EXPECT_NEAR(14.7, c, 1e-10);
+ EXPECT_EQ("b", d);
+
+ EXPECT_TRUE(folly::split<false>(':', "b:14:15.3:c", a, b, c, d));
+ EXPECT_EQ("b", a);
+ EXPECT_EQ(14, b);
+ EXPECT_NEAR(15.3, c, 1e-10);
+ EXPECT_EQ("c", d);
+
+ EXPECT_FALSE(folly::split(':', "a:13:14.7:b", a, b, d));
+
+ EXPECT_TRUE(folly::split<false>(':', "a:13:14.7:b", a, b, d));
+ EXPECT_EQ("a", a);
+ EXPECT_EQ(13, b);
+ EXPECT_EQ("14.7:b", d);
+
+ EXPECT_THROW(folly::split<false>(':', "a:13:14.7:b", a, b, c),
+ std::range_error);
+}
+
TEST(String, join) {
string output;
BENCHMARK(boost_splitOnSingleChar, iters) {
static const std::string line = "one:two:three:four";
+ bool(*pred)(char) = [] (char c) -> bool { return c == ':'; };
for (int i = 0; i < iters << 4; ++i) {
std::vector<boost::iterator_range<std::string::const_iterator> > pieces;
- boost::split(pieces, line, [] (char c) { return c == ':'; });
+ boost::split(pieces, line, pred);
}
}
}
return ret;
}
-