/*
- * 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.
* limitations under the License.
*/
-#include "folly/String.h"
+#include <folly/String.h>
#include <random>
#include <boost/algorithm/string.hpp>
#include <gtest/gtest.h>
-#include "folly/Benchmark.h"
+#include <folly/Benchmark.h>
using namespace folly;
using namespace std;
}
} // 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[2], "kdbk");
parts.clear();
+ // test last part is shorter than the delimiter
+ folly::split("bc", "abcd", parts, true);
+ EXPECT_EQ(parts.size(), 2);
+ EXPECT_EQ(parts[0], "a");
+ EXPECT_EQ(parts[1], "d");
+ parts.clear();
+
string orig = "ab2342asdfv~~!";
folly::split("", orig, parts, true);
EXPECT_EQ(parts.size(), 1);
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, std_string_fixed) {
+ std::string a, b, c, d;
+
+ EXPECT_TRUE(folly::split<false>('.', "a.b.c.d", a, b, c, d));
+ EXPECT_TRUE(folly::split<false>('.', "a.b.c", a, b, c));
+ EXPECT_TRUE(folly::split<false>('.', "a.b", a, b));
+ EXPECT_TRUE(folly::split<false>('.', "a", a));
+
+ EXPECT_TRUE(folly::split('.', "a.b.c.d", a, b, c, d));
+ EXPECT_TRUE(folly::split('.', "a.b.c", a, b, c));
+ EXPECT_TRUE(folly::split('.', "a.b", a, b));
+ EXPECT_TRUE(folly::split('.', "a", a));
+
+ EXPECT_TRUE(folly::split<false>('.', "a.b.c", a, b, c));
+ EXPECT_EQ("a", a);
+ EXPECT_EQ("b", b);
+ EXPECT_EQ("c", c);
+ EXPECT_FALSE(folly::split<false>('.', "a.b", a, b, c));
+ EXPECT_TRUE(folly::split<false>('.', "a.b.c", a, b));
+ EXPECT_EQ("a", a);
+ EXPECT_EQ("b.c", b);
+
+ EXPECT_TRUE(folly::split('.', "a.b.c", a, b, c));
+ EXPECT_EQ("a", a);
+ EXPECT_EQ("b", b);
+ EXPECT_EQ("c", c);
+ EXPECT_FALSE(folly::split('.', "a.b.c", a, b));
+ EXPECT_FALSE(folly::split('.', "a.b", a, b, c));
+
+ EXPECT_TRUE(folly::split<false>('.', "a.b", a, b));
+ EXPECT_EQ("a", a);
+ EXPECT_EQ("b", b);
+ EXPECT_FALSE(folly::split<false>('.', "a", a, b));
+ EXPECT_TRUE(folly::split<false>('.', "a.b", a));
+ EXPECT_EQ("a.b", a);
+
+ EXPECT_TRUE(folly::split('.', "a.b", a, b));
+ EXPECT_EQ("a", a);
+ EXPECT_EQ("b", b);
+ EXPECT_FALSE(folly::split('.', "a", a, b));
+ 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;
EXPECT_EQ("0x61ffffffffff", humanify(string("a\xff\xff\xff\xff\xff")));
}
+TEST(String, exceptionStr) {
+ EXPECT_EQ(exceptionStr(0), "int");
+ EXPECT_EQ(exceptionStr(std::exception()), "std::exception: std::exception");
+ EXPECT_EQ(exceptionStr(std::runtime_error("folly")),
+ "std::runtime_error: folly");
+}
+
+namespace {
+
+/**
+ * Copy bytes from src to somewhere in the buffer referenced by dst. The
+ * actual starting position of the copy will be the first address in the
+ * destination buffer whose address mod 8 is equal to the src address mod 8.
+ * The caller is responsible for ensuring that the destination buffer has
+ * enough extra space to accommodate the shifted copy.
+ */
+char* copyWithSameAlignment(char* dst, const char* src, size_t length) {
+ const char* originalDst = dst;
+ size_t dstOffset = size_t(dst) & 0x7;
+ size_t srcOffset = size_t(src) & 0x7;
+ while (dstOffset != srcOffset) {
+ dst++;
+ dstOffset++;
+ dstOffset &= 0x7;
+ }
+ CHECK(dst <= originalDst + 7);
+ CHECK((size_t(dst) & 0x7) == (size_t(src) & 0x7));
+ memcpy(dst, src, length);
+ return dst;
+}
+
+void testToLowerAscii(Range<const char*> src) {
+ // Allocate extra space so we can make copies that start at the
+ // same alignment (byte, word, quadword, etc) as the source buffer.
+ char controlBuf[src.size() + 7];
+ char* control = copyWithSameAlignment(controlBuf, src.begin(), src.size());
+
+ char testBuf[src.size() + 7];
+ char* test = copyWithSameAlignment(testBuf, src.begin(), src.size());
+
+ for (size_t i = 0; i < src.size(); i++) {
+ control[i] = tolower(control[i]);
+ }
+ toLowerAscii(test, src.size());
+ for (size_t i = 0; i < src.size(); i++) {
+ EXPECT_EQ(control[i], test[i]);
+ }
+}
+
+} // anon namespace
+
+TEST(String, toLowerAsciiAligned) {
+ static const size_t kSize = 256;
+ char input[kSize];
+ for (size_t i = 0; i < kSize; i++) {
+ input[i] = (char)(i & 0xff);
+ }
+ testToLowerAscii(Range<const char*>(input, kSize));
+}
+
+TEST(String, toLowerAsciiUnaligned) {
+ static const size_t kSize = 256;
+ char input[kSize];
+ for (size_t i = 0; i < kSize; i++) {
+ input[i] = (char)(i & 0xff);
+ }
+ // Test input buffers of several lengths to exercise all the
+ // cases: buffer at the start/middle/end of an aligned block, plus
+ // buffers that span multiple aligned blocks. The longest test input
+ // is 3 unaligned bytes + 4 32-bit aligned bytes + 8 64-bit aligned
+ // + 4 32-bit aligned + 3 unaligned = 22 bytes.
+ for (size_t length = 1; length < 23; length++) {
+ for (size_t offset = 0; offset + length <= kSize; offset++) {
+ testToLowerAscii(Range<const char*>(input + offset, length));
+ }
+ }
+}
+
//////////////////////////////////////////////////////////////////////
BENCHMARK(splitOnSingleChar, iters) {
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);
}
}
int main(int argc, char *argv[]) {
testing::InitGoogleTest(&argc, argv);
- google::ParseCommandLineFlags(&argc, &argv, true);
+ gflags::ParseCommandLineFlags(&argc, &argv, true);
auto ret = RUN_ALL_TESTS();
if (!ret) {
initBenchmark();
}
return ret;
}
-
projects / folly.git / blobdiff