FormatOtherTest.cpp File Reference

#include <folly/Format.h>
#include <glog/logging.h>
#include <folly/FBVector.h>
#include <folly/FileUtil.h>
#include <folly/Portability.h>
#include <folly/dynamic.h>
#include <folly/json.h>
#include <folly/portability/GTest.h>
#include <folly/small_vector.h>

Go to the source code of this file.

Functions
	TEST (FormatOther, file)
	TEST (FormatOther, dynamic)
	TEST (FormatOther, fbvector)
	TEST (FormatOther, small_vector)
int	main (int argc, char *argv[])

Function Documentation

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 111 of file FormatOtherTest.cpp.

References testing::InitGoogleTest(), and RUN_ALL_TESTS().

                                 {
  testing::InitGoogleTest(&argc, argv);
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  return RUN_ALL_TESTS();
}

TEST	(	FormatOther	,
		file
	)

Definition at line 31 of file FormatOtherTest.cpp.

References folly::closeNoInt(), EXPECT_EQ, FILE, folly::format(), folly::kIsWindows, pipe(), folly::readFull(), SCOPE_EXIT, string, and folly::writeTo().

                        {
  // Test writing to FILE. I'd use open_memstream but that's not available
  // outside of Linux (even though it's in POSIX.1-2008).
  {
    int fds[2];
    CHECK_ERR(pipe(fds));
    SCOPE_EXIT {
      // fclose on Windows automatically closes the underlying
      // file descriptor.
      if (!kIsWindows) {
        closeNoInt(fds[1]);
      }
    };
    {
      FILE* fp = fdopen(fds[1], "wb");
      PCHECK(fp);
      SCOPE_EXIT {
        fclose(fp);
      };
      writeTo(fp, format("{} {}", 42, 23)); // <= 512 bytes (PIPE_BUF)
    }

    char buf[512];
    ssize_t n = readFull(fds[0], buf, sizeof(buf));
    CHECK_GE(n, 0);

    EXPECT_EQ("42 23", std::string(buf, n));
  }
}

TEST	(	FormatOther	,
		dynamic
	)

Definition at line 61 of file FormatOtherTest.cpp.

References folly::defaulted(), EXPECT_EQ, EXPECT_THROW, folly::parseJson(), folly::sformat(), folly::svformat(), and folly::T.

                           {
  auto dyn = parseJson(
      "{\n"
      "  \"hello\": \"world\",\n"
      "  \"x\": [20, 30],\n"
      "  \"y\": {\"a\" : 42}\n"
      "}");

  EXPECT_EQ("world", sformat("{0[hello]}", dyn));
  EXPECT_THROW(sformat("{0[none]}", dyn), std::out_of_range);
  EXPECT_EQ("world", sformat("{0[hello]}", defaulted(dyn, "meow")));
  EXPECT_EQ("meow", sformat("{0[none]}", defaulted(dyn, "meow")));

  EXPECT_EQ("20", sformat("{0[x.0]}", dyn));
  EXPECT_THROW(sformat("{0[x.2]}", dyn), std::out_of_range);

  // No support for "deep" defaulting (dyn["x"] is not defaulted)
  auto v = dyn.at("x");
  EXPECT_EQ("20", sformat("{0[0]}", v));
  EXPECT_THROW(sformat("{0[2]}", v), std::out_of_range);
  EXPECT_EQ("20", sformat("{0[0]}", defaulted(v, 42)));
  EXPECT_EQ("42", sformat("{0[2]}", defaulted(v, 42)));

  EXPECT_EQ("42", sformat("{0[y.a]}", dyn));

  EXPECT_EQ("(null)", sformat("{}", dynamic(nullptr)));
}

TEST	(	FormatOther	,
		fbvector
	)

Definition at line 103 of file FormatOtherTest.cpp.

                            {
  testFormatSeq<fbvector<int>>();
}

TEST	(	FormatOther	,
		small_vector
	)

Definition at line 107 of file FormatOtherTest.cpp.

                                {
  testFormatSeq<small_vector<int, 2>>();
}