StringTest.cpp File Reference

#include <folly/String.h>
#include <tuple>
#include <cinttypes>
#include <set>
#include <boost/regex.hpp>
#include <folly/container/Array.h>
#include <folly/portability/GTest.h>
#include <folly/test/TestUtils.h>

Go to the source code of this file.

Classes
struct	PrettyTestCase
struct	my::ColorError

Namespaces
	my

Macros
#define	__STDC_FORMAT_MACROS   1

Enumerations
enum	my::Color { my::Color::Red, my::Color::Blue }
enum	my::ColorErrorCode { my::ColorErrorCode::INVALID_COLOR }

Functions
	TEST (StringPrintf, BasicTest)
	TEST (StringPrintf, NumericFormats)
	TEST (StringPrintf, Appending)
void	vprintfCheck (const char *expected, const char *fmt,...)
void	vprintfError (const char *fmt,...)
	TEST (StringPrintf, VPrintf)
	TEST (StringPrintf, VariousSizes)
	TEST (StringPrintf, oldStringPrintfTests)
	TEST (StringPrintf, oldStringAppendf)
	TEST (Escape, cEscape)
	TEST (Escape, cUnescape)
	TEST (Escape, uriEscape)
	TEST (Escape, uriUnescape)
	TEST (Escape, uriEscapeAllCombinations)
	TEST (Escape, uriUnescapePercentDecoding)
	TEST (PrettyPrint, Basic)
	TEST (PrettyToDouble, Basic)
	TEST (PrettyPrint, HexDump)
	TEST (System, errnoStr)
	TEST (Split, split_vector)
	TEST (Split, split_fbvector)
	TEST (Split, pieces_vector)
	TEST (Split, pieces_fbvector)
	TEST (Split, fixed)
	TEST (Split, std_string_fixed)
	TEST (Split, fixed_convert)
ColorError	my::makeConversionError (ColorErrorCode, StringPiece sp)
Expected< StringPiece, ColorErrorCode >	my::parseTo (StringPiece in, Color &out) noexcept
	TEST (Split, fixed_convert_custom)
	TEST (String, join)
	TEST (String, hexlify)
	TEST (String, unhexlify)
	TEST (String, backslashify)
	TEST (String, humanify)
	TEST (String, toLowerAsciiAligned)
	TEST (String, toLowerAsciiUnaligned)
	TEST (String, whitespace)
	TEST (String, stripLeftMargin_really_empty)
	TEST (String, stripLeftMargin_empty)
	TEST (String, stripLeftMargin_only_whitespace)
	TEST (String, stripLeftMargin_only_uneven_whitespace)
	TEST (String, stripLeftMargin_one_line)
	TEST (String, stripLeftMargin_two_lines)
	TEST (String, stripLeftMargin_three_lines_uneven)
	TEST (String, stripLeftMargin_preceding_blank_lines)
	TEST (String, stripLeftMargin_succeeding_blank_lines)
	TEST (String, stripLeftMargin_interstitial_undented_whiteline)
	TEST (String, stripLeftMargin_interstitial_dedented_whiteline)
	TEST (String, stripLeftMargin_interstitial_equidented_whiteline)
	TEST (String, stripLeftMargin_interstitial_indented_whiteline)
	TEST (String, stripLeftMargin_no_pre_whitespace)
	TEST (String, stripLeftMargin_no_post_whitespace)

Variables
PrettyTestCase	prettyTestCases []

Macro Definition Documentation

#define __STDC_FORMAT_MACROS   1

Definition at line 18 of file StringTest.cpp.

Function Documentation

TEST	(	StringPrintf	,
		BasicTest
	)

Definition at line 36 of file StringTest.cpp.

References EXPECT_EQ, and folly::stringPrintf().

                              {
  EXPECT_EQ("abc", stringPrintf("%s", "abc"));
  EXPECT_EQ("abc", stringPrintf("%sbc", "a"));
  EXPECT_EQ("abc", stringPrintf("a%sc", "b"));
  EXPECT_EQ("abc", stringPrintf("ab%s", "c"));

  EXPECT_EQ("abc", stringPrintf("abc"));
}

TEST	(	StringPrintf	,
		NumericFormats
	)

Definition at line 45 of file StringTest.cpp.

References EXPECT_EQ, and folly::stringPrintf().

                                   {
  EXPECT_EQ("12", stringPrintf("%d", 12));
  EXPECT_EQ("2000000000", stringPrintf("%ld", 2000000000UL));
  EXPECT_EQ("2000000000", stringPrintf("%ld", 2000000000L));
  EXPECT_EQ("-2000000000", stringPrintf("%ld", -2000000000L));
  EXPECT_EQ("5000000000", stringPrintf("%lld", 5000000000ULL));
  EXPECT_EQ("5000000000", stringPrintf("%lld", 5000000000LL));
  EXPECT_EQ("-5000000000", stringPrintf("%lld", -5000000000LL));
  EXPECT_EQ("-1", stringPrintf("%d", 0xffffffff));
  EXPECT_EQ(
      "-1",
      stringPrintf("%" PRId64, static_cast<int64_t>(0xffffffffffffffffLL)));
  EXPECT_EQ(
      "-1",
      stringPrintf("%" PRId64, static_cast<uint64_t>(0xffffffffffffffffULL)));

  EXPECT_EQ("7.7", stringPrintf("%1.1f", 7.7));
  EXPECT_EQ("7.7", stringPrintf("%1.1lf", 7.7));
  EXPECT_EQ("7.70000000000000018", stringPrintf("%.17f", 7.7));
  EXPECT_EQ("7.70000000000000018", stringPrintf("%.17lf", 7.7));
}

TEST	(	StringPrintf	,
		Appending
	)

Definition at line 67 of file StringTest.cpp.

References EXPECT_EQ, s, and folly::stringAppendf().

                              {
  string s;
  stringAppendf(&s, "a%s", "b");
  stringAppendf(&s, "%c", 'c');
  EXPECT_EQ(s, "abc");
  stringAppendf(&s, " %d", 123);
  EXPECT_EQ(s, "abc 123");
}

TEST	(	StringPrintf	,
		VPrintf
	)

Definition at line 122 of file StringTest.cpp.

References vprintfCheck(), and vprintfError().

                            {
  vprintfCheck("foo", "%s", "foo");
  vprintfCheck(
      "long string requiring reallocation 1 2 3 0x12345678",
      "%s %s %d %d %d %#x",
      "long string",
      "requiring reallocation",
      1,
      2,
      3,
      0x12345678);
  vprintfError("bogus%", "foo");
}

TEST	(	StringPrintf	,
		VariousSizes
	)

Definition at line 136 of file StringTest.cpp.

References EXPECT_EQ, i, and folly::stringPrintf().

                                 {
  // Test a wide variety of output sizes, making sure to cross the
  // vsnprintf buffer boundary implementation detail.
  for (int i = 0; i < 4096; ++i) {
    string expected(i + 1, 'a');
    expected = "X" + expected + "X";
    string result = stringPrintf("%s", expected.c_str());
    EXPECT_EQ(expected.size(), result.size());
    EXPECT_EQ(expected, result);
  }

  // clang-format off
  EXPECT_EQ("abc12345678910111213141516171819202122232425xyz",
            stringPrintf("abc%d%d%d%d%d%d%d%d%d%d%d%d%d%d"
                         "%d%d%d%d%d%d%d%d%d%d%dxyz",
                         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
                         17, 18, 19, 20, 21, 22, 23, 24, 25));
  // clang-format on
}

TEST	(	StringPrintf	,
		oldStringPrintfTests
	)

Definition at line 156 of file StringTest.cpp.

References a, b, EXPECT_EQ, folly::size(), and folly::stringPrintf().

                                         {
  EXPECT_EQ(string("a/b/c/d"), stringPrintf("%s/%s/%s/%s", "a", "b", "c", "d"));

  EXPECT_EQ(string("    5    10"), stringPrintf("%5d %5d", 5, 10));

  // check printing w/ a big buffer
  for (int size = (1 << 8); size <= (1 << 15); size <<= 1) {
    string a(size, 'z');
    string b = stringPrintf("%s", a.c_str());
    EXPECT_EQ(a.size(), b.size());
  }
}

TEST	(	StringPrintf	,
		oldStringAppendf
	)

Definition at line 169 of file StringTest.cpp.

References EXPECT_EQ, s, and folly::stringAppendf().

                                     {
  string s = "hello";
  stringAppendf(&s, "%s/%s/%s/%s", "a", "b", "c", "d");
  EXPECT_EQ(string("helloa/b/c/d"), s);
}

TEST	(	Escape	,
		cEscape
	)

Definition at line 175 of file StringTest.cpp.

References EXPECT_EQ.

                      {
  EXPECT_EQ("hello world", cEscape<std::string>("hello world"));
  EXPECT_EQ(
      "hello \\\\world\\\" goodbye",
      cEscape<std::string>("hello \\world\" goodbye"));
  EXPECT_EQ("hello\\nworld", cEscape<std::string>("hello\nworld"));
  EXPECT_EQ("hello\\377\\376", cEscape<std::string>("hello\xff\xfe"));
}

TEST	(	Escape	,
		cUnescape
	)

Definition at line 184 of file StringTest.cpp.

References EXPECT_EQ, and EXPECT_THROW_RE.

                        {
  EXPECT_EQ("hello world", cUnescape<std::string>("hello world"));
  EXPECT_EQ(
      "hello \\world\" goodbye",
      cUnescape<std::string>("hello \\\\world\\\" goodbye"));
  EXPECT_EQ("hello\nworld", cUnescape<std::string>("hello\\nworld"));
  EXPECT_EQ("hello\nworld", cUnescape<std::string>("hello\\012world"));
  EXPECT_EQ("hello\nworld", cUnescape<std::string>("hello\\x0aworld"));
  EXPECT_EQ("hello\xff\xfe", cUnescape<std::string>("hello\\377\\376"));
  EXPECT_EQ("hello\xff\xfe", cUnescape<std::string>("hello\\xff\\xfe"));
  EXPECT_EQ("hello\\", cUnescape<std::string>("hello\\", false));

  EXPECT_THROW_RE(
      cUnescape<std::string>("hello\\"),
      std::invalid_argument,
      "incomplete escape sequence");
  EXPECT_THROW_RE(
      cUnescape<std::string>("hello\\x"),
      std::invalid_argument,
      "incomplete hex escape sequence");
  EXPECT_THROW_RE(
      cUnescape<std::string>("hello\\q"),
      std::invalid_argument,
      "invalid escape sequence");
}

TEST	(	Escape	,
		uriEscape
	)

Definition at line 210 of file StringTest.cpp.

References EXPECT_EQ, folly::PATH, and folly::QUERY.

                        {
  EXPECT_EQ("hello%2c%20%2fworld", uriEscape<std::string>("hello, /world"));
  EXPECT_EQ(
      "hello%2c%20/world",
      uriEscape<std::string>("hello, /world", UriEscapeMode::PATH));
  EXPECT_EQ(
      "hello%2c+%2fworld",
      uriEscape<std::string>("hello, /world", UriEscapeMode::QUERY));
  EXPECT_EQ(
      "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_.~",
      uriEscape<std::string>(
          "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_.~"));
}

TEST	(	Escape	,
		uriUnescape
	)

Definition at line 224 of file StringTest.cpp.

References c, EXPECT_EQ, EXPECT_GE, EXPECT_LE, EXPECT_THROW, folly::QUERY, and s.

                          {
  EXPECT_EQ("hello, /world", uriUnescape<std::string>("hello, /world"));
  EXPECT_EQ("hello, /world", uriUnescape<std::string>("hello%2c%20%2fworld"));
  EXPECT_EQ("hello,+/world", uriUnescape<std::string>("hello%2c+%2fworld"));
  EXPECT_EQ(
      "hello, /world",
      uriUnescape<std::string>("hello%2c+%2fworld", UriEscapeMode::QUERY));
  EXPECT_EQ("hello/", uriUnescape<std::string>("hello%2f"));
  EXPECT_EQ("hello/", uriUnescape<std::string>("hello%2F"));
  EXPECT_THROW({ uriUnescape<std::string>("hello%"); }, std::invalid_argument);
  EXPECT_THROW({ uriUnescape<std::string>("hello%2"); }, std::invalid_argument);
  EXPECT_THROW(
      { uriUnescape<std::string>("hello%2g"); }, std::invalid_argument);
}

TEST	(	Escape	,
		uriEscapeAllCombinations
	)

Definition at line 248 of file StringTest.cpp.

References c, folly::basic_fbstring< E, T, A, Storage >::clear(), EXPECT_EQ, i, folly::uriEscape(), and folly::uriUnescape().

                                       {
  char c[3];
  c[2] = '\0';
  StringPiece in(c, 2);
  fbstring tmp;
  fbstring out;
  for (int i = 0; i < 256; ++i) {
    c[0] = i;
    for (int j = 0; j < 256; ++j) {
      c[1] = j;
      tmp.clear();
      out.clear();
      uriEscape(in, tmp);
      expectPrintable(tmp);
      uriUnescape(tmp, out);
      EXPECT_EQ(in, out);
    }
  }
}

TEST	(	Escape	,
		uriUnescapePercentDecoding
	)

Definition at line 276 of file StringTest.cpp.

References c, folly::basic_fbstring< E, T, A, Storage >::clear(), EXPECT_EQ, EXPECT_THROW, i, int64_t, folly::basic_fbstring< E, T, A, Storage >::size(), and folly::uriUnescape().

                                         {
  char c[4] = {'%', '\0', '\0', '\0'};
  StringPiece in(c, 3);
  fbstring out;
  unsigned int expected = 0;
  for (int i = 0; i < 256; ++i) {
    c[1] = i;
    for (int j = 0; j < 256; ++j) {
      c[2] = j;
      if (isHex(i) && isHex(j)) {
        out.clear();
        uriUnescape(in, out);
        EXPECT_EQ(1, out.size());
        EXPECT_EQ(1, sscanf(c + 1, "%x", &expected));
        unsigned char v = out[0];
        EXPECT_EQ(expected, v);
      } else {
        EXPECT_THROW({ uriUnescape(in, out); }, std::invalid_argument);
      }
    }
  }
}

TEST	(	PrettyPrint	,
		Basic
	)

Definition at line 438 of file StringTest.cpp.

References EXPECT_EQ, i, folly::PRETTY_NUM_TYPES, folly::prettyPrint(), PrettyTestCase::prettyString, PrettyTestCase::prettyType, and PrettyTestCase::realValue.

                         {
  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
	)

Definition at line 447 of file StringTest.cpp.

References ADD_FAILURE, folly::exceptionStr(), EXPECT_DOUBLE_EQ, EXPECT_EQ, EXPECT_NEAR, EXPECT_THROW, i, folly::PRETTY_NUM_TYPES, folly::PRETTY_SI, folly::PRETTY_UNITS_METRIC, folly::prettyPrint(), PrettyTestCase::prettyString, folly::prettyToDouble(), PrettyTestCase::prettyType, PrettyTestCase::realValue, string, and x.

                            {
  // 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 = 0;
    try {
      recoveredX = prettyToDouble(testString, formatType);
    } catch (const std::exception& ex) {
      ADD_FAILURE() << testCase.prettyString << " -> " << ex.what();
    }
    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 = 0;
        try {
          recoveredX =
              prettyToDouble(prettyPrint(x, formatType, addSpace), formatType);
        } catch (const std::exception& ex) {
          ADD_FAILURE() << folly::exceptionStr(ex);
        }
        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
	)

Definition at line 494 of file StringTest.cpp.

References a, EXPECT_EQ, folly::hexDump(), and string.

                           {
  std::string a("abc\x00\x02\xa0", 6); // embedded NUL
  EXPECT_EQ(
      "00000000  61 62 63 00 02 a0                                 "
      "|abc...          |\n",
      hexDump(a.data(), a.size()));

  a = "abcdefghijklmnopqrstuvwxyz";
  EXPECT_EQ(
      "00000000  61 62 63 64 65 66 67 68  69 6a 6b 6c 6d 6e 6f 70  "
      "|abcdefghijklmnop|\n"
      "00000010  71 72 73 74 75 76 77 78  79 7a                    "
      "|qrstuvwxyz      |\n",
      hexDump(a.data(), a.size()));
}

TEST	(	System	,
		errnoStr
	)

Definition at line 510 of file StringTest.cpp.

References folly::errnoStr(), EXPECT_EQ, folly::split(), and start.

                       {
  errno = EACCES;
  EXPECT_EQ(EACCES, errno);
  EXPECT_EQ(EACCES, errno); // twice to make sure EXPECT_EQ doesn't change it

  fbstring expected = strerror(ENOENT);

  errno = EACCES;
  EXPECT_EQ(expected, errnoStr(ENOENT));
  // Ensure that errno isn't changed
  EXPECT_EQ(EACCES, errno);

  // Per POSIX, all errno values are positive, so -1 is invalid
  errnoStr(-1);

  // Ensure that errno isn't changed
  EXPECT_EQ(EACCES, errno);
}

TEST	(	Split	,
		split_vector
	)

Definition at line 832 of file StringTest.cpp.

                          {
  splitTest<std::vector>();
}

TEST	(	Split	,
		split_fbvector
	)

Definition at line 835 of file StringTest.cpp.

                            {
  splitTest<folly::fbvector>();
}

TEST	(	Split	,
		pieces_vector
	)

Definition at line 838 of file StringTest.cpp.

                           {
  piecesTest<std::vector>();
}

TEST	(	Split	,
		pieces_fbvector
	)

Definition at line 841 of file StringTest.cpp.

                             {
  piecesTest<folly::fbvector>();
}

TEST	(	Split	,
		fixed
	)

Definition at line 845 of file StringTest.cpp.

References a, b, c, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, and folly::split().

                   {
  StringPiece 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	,
		std_string_fixed
	)

Definition at line 888 of file StringTest.cpp.

References a, b, c, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::split(), and string.

                              {
  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
	)

Definition at line 931 of file StringTest.cpp.

References a, b, c, EXPECT_EQ, EXPECT_FALSE, EXPECT_NEAR, EXPECT_TRUE, and folly::split().

                           {
  StringPiece a, d;
  int b;
  double c = 0;

  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);

  // Enable verifying that a line only contains one field
  EXPECT_TRUE(folly::split(' ', "hello", a));
  EXPECT_FALSE(folly::split(' ', "hello world", a));

  // Test cases with std::ignore.
  EXPECT_TRUE(folly::split(':', "a:13:14.7:b", std::ignore, b, c, d));
  EXPECT_EQ(13, b);
  EXPECT_NEAR(14.7, c, 1e-10);
  EXPECT_EQ("b", d);

  EXPECT_TRUE(folly::split(':', "a:13:14.7:b", std::ignore, b, c, std::ignore));
  EXPECT_EQ(13, b);
  EXPECT_NEAR(14.7, c, 1e-10);

  EXPECT_TRUE(folly::split<false>(':', "a:13:14.7:b", a, b, std::ignore));
  EXPECT_EQ("a", a);
  EXPECT_EQ(13, b);

  EXPECT_FALSE(folly::split<false>(':', "a:13", std::ignore, b, std::ignore));
  EXPECT_TRUE(folly::split<false>(':', ":13:", std::ignore, b, std::ignore));
  EXPECT_EQ(13, b);
}

TEST	(	Split	,
		fixed_convert_custom
	)

Definition at line 1009 of file StringTest.cpp.

References my::Blue, EXPECT_EQ, EXPECT_THROW, EXPECT_TRUE, my::Red, and folly::split().

                                  {
  my::Color c1, c2;

  EXPECT_TRUE(folly::split(',', "R,B", c1, c2));
  EXPECT_EQ(c1, my::Color::Red);
  EXPECT_EQ(c2, my::Color::Blue);

  EXPECT_THROW(folly::split(',', "B,G", c1, c2), my::ColorError);
}

TEST	(	String	,
		join
	)

Definition at line 1019 of file StringTest.cpp.

References folly::empty(), EXPECT_EQ, EXPECT_TRUE, folly::join(), and gmock_output_test::output.

                   {
  string output;

  std::vector<int> empty = {};
  join(":", empty, output);
  EXPECT_TRUE(output.empty());

  std::vector<std::string> input1 = {"1", "23", "456", ""};
  join(':', input1, output);
  EXPECT_EQ(output, "1:23:456:");
  output = join(':', input1);
  EXPECT_EQ(output, "1:23:456:");

  auto input2 = {1, 23, 456};
  join("-*-", input2, output);
  EXPECT_EQ(output, "1-*-23-*-456");
  output = join("-*-", input2);
  EXPECT_EQ(output, "1-*-23-*-456");

  auto input3 = {'f', 'a', 'c', 'e', 'b', 'o', 'o', 'k'};
  join("", input3, output);
  EXPECT_EQ(output, "facebook");

  join("_", {"", "f", "a", "c", "e", "b", "o", "o", "k", ""}, output);
  EXPECT_EQ(output, "_f_a_c_e_b_o_o_k_");

  output = join("", input3.begin(), input3.end());
  EXPECT_EQ(output, "facebook");

  std::multiset<char> input4(input3);
  output = join("", input4);
  EXPECT_EQ("abcefkoo", output);
  output = join("", input4.begin(), input4.end());
  EXPECT_EQ("abcefkoo", output);
}

TEST	(	String	,
		hexlify
	)

Definition at line 1055 of file StringTest.cpp.

References folly::Range< Iter >::data(), EXPECT_EQ, EXPECT_TRUE, and folly::hexlify().

                      {
  string input1 = "0123";
  string output1;
  EXPECT_TRUE(hexlify(input1, output1));
  EXPECT_EQ("30313233", output1);

  fbstring input2 = "abcdefg";
  input2[1] = 0;
  input2[3] = 0xff;
  input2[5] = 0xb6;
  fbstring output2;
  EXPECT_TRUE(hexlify(input2, output2));
  EXPECT_EQ("610063ff65b667", output2);

  EXPECT_EQ("666f6f626172", hexlify("foobar"));
  auto bytes = folly::make_array<uint8_t>(1, 2, 3, 4);
  EXPECT_EQ("01020304", hexlify(ByteRange{bytes.data(), bytes.size()}));
}

TEST	(	String	,
		unhexlify
	)

Definition at line 1074 of file StringTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_THROW, EXPECT_TRUE, folly::basic_fbstring< E, T, A, Storage >::size(), and folly::unhexlify().

                        {
  string input1 = "30313233";
  string output1;
  EXPECT_TRUE(unhexlify(input1, output1));
  EXPECT_EQ(output1, "0123");

  fbstring input2 = "610063ff65b667";
  fbstring output2;
  EXPECT_TRUE(unhexlify(input2, output2));
  EXPECT_EQ(output2.size(), 7);
  EXPECT_EQ(output2[0], 'a');
  EXPECT_EQ(output2[1], 0);
  EXPECT_EQ(output2[2], 'c');
  EXPECT_EQ(output2[3] & 0xff, 0xff);
  EXPECT_EQ(output2[4], 'e');
  EXPECT_EQ(output2[5] & 0xff, 0xb6);
  EXPECT_EQ(output2[6], 'g');

  string input3 = "x";
  string output3;
  EXPECT_FALSE(unhexlify(input3, output3));

  string input4 = "xy";
  string output4;
  EXPECT_FALSE(unhexlify(input4, output4));

  EXPECT_EQ("foobar", unhexlify("666f6f626172"));
  EXPECT_EQ(StringPiece("foo\0bar", 7), unhexlify("666f6f00626172"));
  EXPECT_THROW(unhexlify("666f6fzz626172"), std::domain_error);
}

TEST	(	String	,
		backslashify
	)

Definition at line 1105 of file StringTest.cpp.

References folly::backslashify(), EXPECT_EQ, and string.

                           {
  EXPECT_EQ("abc", string("abc"));
  EXPECT_EQ("abc", backslashify(string("abc")));
  EXPECT_EQ("abc\\r", backslashify(string("abc\r")));
  EXPECT_EQ("abc\\x0d", backslashify(string("abc\r"), true));
  EXPECT_EQ("\\0\\0", backslashify(string(2, '\0')));

  StringPiece input1 = "abc\r";
  std::string output1 = backslashify(input1);
  EXPECT_EQ("abc\\r", output1);
}

TEST	(	String	,
		humanify
	)

Definition at line 1117 of file StringTest.cpp.

References folly::Range< Iter >::begin(), EXPECT_EQ, folly::humanify(), i, folly::Range< Iter >::size(), and folly::toLowerAscii().

                       {
  // Simple cases; output is obvious.
  EXPECT_EQ("abc", humanify(string("abc")));
  EXPECT_EQ("abc\\\\r", humanify(string("abc\\r")));
  EXPECT_EQ("0xff", humanify(string("\xff")));
  EXPECT_EQ("abc\\xff", humanify(string("abc\xff")));
  EXPECT_EQ("abc\\b", humanify(string("abc\b")));
  EXPECT_EQ("0x00", humanify(string(1, '\0')));
  EXPECT_EQ("0x0000", humanify(string(2, '\0')));

  // Mostly printable, so backslash!  80, 60, and 40% printable, respectively
  EXPECT_EQ("aaaa\\xff", humanify(string("aaaa\xff")));
  EXPECT_EQ("aaa\\xff\\xff", humanify(string("aaa\xff\xff")));
  EXPECT_EQ("aa\\xff\\xff\\xff", humanify(string("aa\xff\xff\xff")));

  // 20% printable, and the printable portion isn't the prefix; hexify!
  EXPECT_EQ(
      "0xff61ffffff",
      humanify(string("\xff"
                      "a\xff\xff\xff")));

  // Same as previous, except swap first two chars; prefix is
  // printable and within the threshold, so backslashify.
  EXPECT_EQ("a\\xff\\xff\\xff\\xff", humanify(string("a\xff\xff\xff\xff")));

  // Just too much unprintable; hex, despite prefix.
  EXPECT_EQ("0x61ffffffffff", humanify(string("a\xff\xff\xff\xff\xff")));
}

TEST	(	String	,
		toLowerAsciiAligned
	)

Definition at line 1191 of file StringTest.cpp.

References i.

                                  {
  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
	)

Definition at line 1200 of file StringTest.cpp.

References i.

                                    {
  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));
    }
  }
}

TEST	(	String	,
		whitespace
	)

Definition at line 1218 of file StringTest.cpp.

References EXPECT_EQ, folly::ltrimWhitespace(), folly::rtrimWhitespace(), and folly::trimWhitespace().

                         {
  // trimWhitespace:
  EXPECT_EQ("kavabanga", trimWhitespace("kavabanga"));
  EXPECT_EQ("kavabanga", trimWhitespace("kavabanga \t \n  "));
  EXPECT_EQ("kavabanga", trimWhitespace("   \t \r \n \n kavabanga"));
  EXPECT_EQ("kavabanga", trimWhitespace("\t \r \n   kavabanga \t \n  "));
  EXPECT_EQ("kavabanga", trimWhitespace("   \t \r \n \n kavabanga"));
  EXPECT_EQ("kavabanga", trimWhitespace("\t \r \n   kavabanga \t \n  "));
  EXPECT_EQ(
      ltrimWhitespace(rtrimWhitespace("kavabanga")),
      rtrimWhitespace(ltrimWhitespace("kavabanga")));
  EXPECT_EQ(
      ltrimWhitespace(rtrimWhitespace("kavabanga  \r\t\n")),
      rtrimWhitespace(ltrimWhitespace("kavabanga  \r\t\n")));
  EXPECT_EQ("", trimWhitespace("\t \r \n   \t \n  "));
  EXPECT_EQ("", trimWhitespace(""));
  EXPECT_EQ("", trimWhitespace("\t"));
  EXPECT_EQ("", trimWhitespace("\r"));
  EXPECT_EQ("", trimWhitespace("\n"));
  EXPECT_EQ("", trimWhitespace("\t "));
  EXPECT_EQ("", trimWhitespace("\r  "));
  EXPECT_EQ("", trimWhitespace("\n   "));
  EXPECT_EQ("", trimWhitespace("    \t"));
  EXPECT_EQ("", trimWhitespace("    \r"));
  EXPECT_EQ("", trimWhitespace("    \n"));

  // ltrimWhitespace:
  EXPECT_EQ("kavabanga", ltrimWhitespace("\t kavabanga"));
  EXPECT_EQ("kavabanga \r\n", ltrimWhitespace("\t kavabanga \r\n"));
  EXPECT_EQ("", ltrimWhitespace("\r "));
  EXPECT_EQ("", ltrimWhitespace("\n   "));
  EXPECT_EQ("", ltrimWhitespace("\r   "));

  // rtrimWhitespace:
  EXPECT_EQ("\t kavabanga", rtrimWhitespace("\t kavabanga"));
  EXPECT_EQ("\t kavabanga", rtrimWhitespace("\t kavabanga \r\n"));
  EXPECT_EQ("", rtrimWhitespace("\r "));
  EXPECT_EQ("", rtrimWhitespace("\n   "));
  EXPECT_EQ("", rtrimWhitespace("\r   "));
}

TEST	(	String	,
		stripLeftMargin_really_empty
	)

Definition at line 1259 of file StringTest.cpp.

References EXPECT_EQ, and folly::stripLeftMargin().

                                           {
  auto input = "";
  auto expected = "";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_empty
	)

Definition at line 1265 of file StringTest.cpp.

References EXPECT_EQ, and folly::stripLeftMargin().

                                    {
  auto input = R"TEXT(
  )TEXT";
  auto expected = "";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_only_whitespace
	)

Definition at line 1272 of file StringTest.cpp.

References EXPECT_EQ, regex, and folly::stripLeftMargin().

                                              {
  //  using ~ as a marker
  string input = R"TEXT(
    ~
  )TEXT";
  input = boost::regex_replace(input, boost::regex("~"), "");
  EXPECT_EQ("\n    \n  ", input);
  auto expected = "\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_only_uneven_whitespace
	)

Definition at line 1283 of file StringTest.cpp.

References EXPECT_EQ, regex, and folly::stripLeftMargin().

                                                     {
  //  using ~ as a marker1
  string input = R"TEXT(
    ~
      ~
  )TEXT";
  input = boost::regex_replace(input, boost::regex("~"), "");
  EXPECT_EQ("\n    \n      \n  ", input);
  auto expected = "\n\n";

  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_one_line
	)

Definition at line 1296 of file StringTest.cpp.

References EXPECT_EQ, and folly::stripLeftMargin().

                                       {
  auto input = R"TEXT(
    hi there bob!
  )TEXT";
  auto expected = "hi there bob!\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_two_lines
	)

Definition at line 1304 of file StringTest.cpp.

References EXPECT_EQ, and folly::stripLeftMargin().

                                        {
  auto input = R"TEXT(
    hi there bob!
    nice weather today!
  )TEXT";
  auto expected = "hi there bob!\nnice weather today!\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_three_lines_uneven
	)

Definition at line 1313 of file StringTest.cpp.

References EXPECT_EQ, and folly::stripLeftMargin().

                                                 {
  auto input = R"TEXT(
      hi there bob!
    nice weather today!
      so long!
  )TEXT";
  auto expected = "  hi there bob!\nnice weather today!\n  so long!\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_preceding_blank_lines
	)

Definition at line 1323 of file StringTest.cpp.

References EXPECT_EQ, and folly::stripLeftMargin().

                                                    {
  auto input = R"TEXT(


    hi there bob!
  )TEXT";
  auto expected = "\n\nhi there bob!\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_succeeding_blank_lines
	)

Definition at line 1333 of file StringTest.cpp.

References EXPECT_EQ, and folly::stripLeftMargin().

                                                     {
  auto input = R"TEXT(
    hi there bob!


  )TEXT";
  auto expected = "hi there bob!\n\n\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_interstitial_undented_whiteline
	)

Definition at line 1343 of file StringTest.cpp.

References EXPECT_EQ, regex, and folly::stripLeftMargin().

                                                              {
  //  using ~ as a marker
  string input = R"TEXT(
      hi there bob!
    ~
      so long!
  )TEXT";
  input = boost::regex_replace(input, boost::regex(" +~"), "");
  EXPECT_EQ("\n      hi there bob!\n\n      so long!\n  ", input);
  auto expected = "hi there bob!\n\nso long!\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_interstitial_dedented_whiteline
	)

Definition at line 1356 of file StringTest.cpp.

References EXPECT_EQ, regex, and folly::stripLeftMargin().

                                                              {
  //  using ~ as a marker
  string input = R"TEXT(
      hi there bob!
    ~
      so long!
  )TEXT";
  input = boost::regex_replace(input, boost::regex("~"), "");
  EXPECT_EQ("\n      hi there bob!\n    \n      so long!\n  ", input);
  auto expected = "hi there bob!\n\nso long!\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_interstitial_equidented_whiteline
	)

Definition at line 1369 of file StringTest.cpp.

References EXPECT_EQ, regex, and folly::stripLeftMargin().

                                                                {
  //  using ~ as a marker
  string input = R"TEXT(
      hi there bob!
      ~
      so long!
  )TEXT";
  input = boost::regex_replace(input, boost::regex("~"), "");
  EXPECT_EQ("\n      hi there bob!\n      \n      so long!\n  ", input);
  auto expected = "hi there bob!\n\nso long!\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_interstitial_indented_whiteline
	)

Definition at line 1382 of file StringTest.cpp.

References EXPECT_EQ, regex, and folly::stripLeftMargin().

                                                              {
  //  using ~ as a marker
  string input = R"TEXT(
      hi there bob!
        ~
      so long!
  )TEXT";
  input = boost::regex_replace(input, boost::regex("~"), "");
  EXPECT_EQ("\n      hi there bob!\n        \n      so long!\n  ", input);
  auto expected = "hi there bob!\n  \nso long!\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_no_pre_whitespace
	)

Definition at line 1395 of file StringTest.cpp.

References EXPECT_EQ, regex, and folly::stripLeftMargin().

                                                {
  //  using ~ as a marker
  string input = R"TEXT(      hi there bob!
        ~
      so long!
  )TEXT";
  input = boost::regex_replace(input, boost::regex("~"), "");
  EXPECT_EQ("      hi there bob!\n        \n      so long!\n  ", input);
  auto expected = "hi there bob!\n  \nso long!\n";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

TEST	(	String	,
		stripLeftMargin_no_post_whitespace
	)

Definition at line 1407 of file StringTest.cpp.

References EXPECT_EQ, regex, and folly::stripLeftMargin().

                                                 {
  //  using ~ as a marker
  string input = R"TEXT(
      hi there bob!
        ~
      so long!  )TEXT";
  input = boost::regex_replace(input, boost::regex("~"), "");
  EXPECT_EQ("\n      hi there bob!\n        \n      so long!  ", input);
  auto expected = "hi there bob!\n  \nso long!  ";
  EXPECT_EQ(expected, stripLeftMargin(input));
}

void vprintfCheck	(	const char *	expected,
		const char *	fmt,
			...
	)

Definition at line 76 of file StringTest.cpp.

References EXPECT_EQ, prefix(), SCOPE_EXIT, string, folly::stringVAppendf(), and folly::stringVPrintf().

Referenced by TEST().

                                                              {
  va_list apOrig;
  va_start(apOrig, fmt);
  SCOPE_EXIT {
    va_end(apOrig);
  };
  va_list ap;
  va_copy(ap, apOrig);
  SCOPE_EXIT {
    va_end(ap);
  };

  // Check both APIs for calling stringVPrintf()
  EXPECT_EQ(expected, stringVPrintf(fmt, ap));
  va_end(ap);
  va_copy(ap, apOrig);

  std::string out;
  stringVPrintf(&out, fmt, ap);
  va_end(ap);
  va_copy(ap, apOrig);
  EXPECT_EQ(expected, out);

  // Check stringVAppendf() as well
  std::string prefix = "foobar";
  out = prefix;
  EXPECT_EQ(prefix + expected, stringVAppendf(&out, fmt, ap));
  va_end(ap);
  va_copy(ap, apOrig);
}

void vprintfError	(	const char *	fmt,
			...
	)

Definition at line 107 of file StringTest.cpp.

References EXPECT_THROW, SCOPE_EXIT, and folly::stringVPrintf().

Referenced by TEST().

                                        {
  va_list ap;
  va_start(ap, fmt);
  SCOPE_EXIT {
    va_end(ap);
  };

#ifdef HAVE_VSNPRINTF_ERRORS
  // OSX's sprintf family does not return a negative number on a bad format
  // string, but Linux does. It's unclear to me which behavior is more
  // correct.
  EXPECT_THROW({ stringVPrintf(fmt, ap); }, std::runtime_error);
#endif
}

Variable Documentation

PrettyTestCase prettyTestCases[]

Definition at line 313 of file StringTest.cpp.