TestUtilTest.cpp File Reference

#include <folly/experimental/TestUtil.h>
#include <system_error>
#include <boost/algorithm/string.hpp>
#include <glog/logging.h>
#include <folly/Memory.h>
#include <folly/portability/Fcntl.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Stdlib.h>

Go to the source code of this file.

Functions
	TEST (TemporaryFile, Simple)
	TEST (TemporaryFile, EarlyClose)
	TEST (TemporaryFile, Prefix)
	TEST (TemporaryFile, PathPrefix)
	TEST (TemporaryFile, NoSuchPath)
	TEST (TemporaryFile, moveAssignment)
	TEST (TemporaryFile, moveCtor)
void	testTemporaryDirectory (TemporaryDirectory::Scope scope)
	TEST (TemporaryDirectory, Permanent)
	TEST (TemporaryDirectory, DeleteOnDestruction)
void	expectTempdirExists (const TemporaryDirectory &d)
	TEST (TemporaryDirectory, SafelyMove)
	TEST (ChangeToTempDir, ChangeDir)
	TEST (PCREPatternMatch, Simple)
	TEST (CaptureFD, GlogPatterns)
	TEST (CaptureFD, ChunkCob)

Function Documentation

void expectTempdirExists

(

const TemporaryDirectory &

d

)

Definition at line 146 of file TestUtilTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and folly::test::TemporaryDirectory::path().

Referenced by TEST().

                                                      {
  EXPECT_FALSE(d.path().empty());
  EXPECT_TRUE(fs::exists(d.path()));
  EXPECT_TRUE(fs::is_directory(d.path()));
}

TEST	(	TemporaryFile	,
		Simple
	)

Definition at line 32 of file TestUtilTest.cpp.

References c, EXPECT_EQ, EXPECT_FALSE, EXPECT_LE, EXPECT_TRUE, f, folly::test::TemporaryFile::fd(), folly::test::msvcSuppressAbortOnInvalidParams(), folly::test::TemporaryFile::path(), and fizz::detail::write().

                            {
  int fd = -1;
  char c = 'x';
  {
    TemporaryFile f;
    EXPECT_FALSE(f.path().empty());
    EXPECT_TRUE(f.path().is_absolute());
    fd = f.fd();
    EXPECT_LE(0, fd);
    ssize_t r = write(fd, &c, 1);
    EXPECT_EQ(1, r);
  }

  msvcSuppressAbortOnInvalidParams([&] {
    // The file must have been closed.  This assumes that no other thread
    // has opened another file in the meanwhile, which is a sane assumption
    // to make in this test.
    ssize_t r = write(fd, &c, 1);
    int savedErrno = errno;
    EXPECT_EQ(-1, r);
    EXPECT_EQ(EBADF, savedErrno);
  });
}

TEST	(	TemporaryFile	,
		EarlyClose
	)

Definition at line 56 of file TestUtilTest.cpp.

References folly::test::TemporaryFile::close(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, f, folly::test::TemporaryFile::fd(), and folly::test::TemporaryFile::path().

                                {
  fs::path p;
  {
    TemporaryFile f;
    p = f.path();
    EXPECT_TRUE(fs::exists(p));
    f.close();
    EXPECT_EQ(-1, f.fd());
    EXPECT_TRUE(fs::exists(p));
  }
  EXPECT_FALSE(fs::exists(p));
}

TEST	(	TemporaryFile	,
		Prefix
	)

Definition at line 69 of file TestUtilTest.cpp.

References EXPECT_TRUE, f, folly::test::TemporaryFile::path(), and folly::fs::starts_with().

                            {
  TemporaryFile f("Foo");
  EXPECT_TRUE(f.path().is_absolute());
  EXPECT_TRUE(
      boost::algorithm::starts_with(f.path().filename().native(), "Foo"));
}

TEST	(	TemporaryFile	,
		PathPrefix
	)

Definition at line 76 of file TestUtilTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, f, folly::test::TemporaryFile::path(), and folly::fs::starts_with().

                                {
  TemporaryFile f("Foo", ".");
  EXPECT_EQ(fs::path("."), f.path().parent_path());
  EXPECT_TRUE(
      boost::algorithm::starts_with(f.path().filename().native(), "Foo"));
}

TEST	(	TemporaryFile	,
		NoSuchPath
	)

Definition at line 83 of file TestUtilTest.cpp.

References EXPECT_THROW, and f.

                                {
  EXPECT_THROW({ TemporaryFile f("", "/no/such/path"); }, std::system_error);
}

TEST	(	TemporaryFile	,
		moveAssignment
	)

Definition at line 87 of file TestUtilTest.cpp.

References EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, f, folly::test::TemporaryFile::fd(), g(), h, folly::gen::move, and folly::test::TemporaryFile::path().

                                    {
  TemporaryFile f;
  int fd;

  EXPECT_TRUE(f.path().is_absolute());
  {
    TemporaryFile g("Foo", ".");
    EXPECT_NE(g.fd(), -1);
    fd = g.fd();
    f = std::move(g);
  }
  EXPECT_EQ(fs::path("."), f.path().parent_path());
  EXPECT_EQ(f.fd(), fd);

  TemporaryFile h = TemporaryFile("FooBar", ".");
  EXPECT_NE(h.fd(), -1);
}

TEST	(	TemporaryFile	,
		moveCtor
	)

Definition at line 105 of file TestUtilTest.cpp.

References EXPECT_EQ, EXPECT_NE, f, folly::test::TemporaryFile::fd(), g(), and folly::gen::move.

                              {
  struct FooBar {
    TemporaryFile f_;
    explicit FooBar(TemporaryFile&& f) : f_(std::move(f)) {}
  };
  TemporaryFile g("Foo");
  FooBar fb(std::move(g));
  EXPECT_EQ(g.fd(), -1);
  EXPECT_NE(fb.f_.fd(), -1);
}

TEST	(	TemporaryDirectory	,
		Permanent
	)

Definition at line 138 of file TestUtilTest.cpp.

References folly::test::TemporaryDirectory::PERMANENT, and testTemporaryDirectory().

                                    {
  testTemporaryDirectory(TemporaryDirectory::Scope::PERMANENT);
}

TEST	(	TemporaryDirectory	,
		DeleteOnDestruction
	)

Definition at line 142 of file TestUtilTest.cpp.

References folly::test::TemporaryDirectory::DELETE_ON_DESTRUCTION, and testTemporaryDirectory().

                                              {
  testTemporaryDirectory(TemporaryDirectory::Scope::DELETE_ON_DESTRUCTION);
}

TEST	(	TemporaryDirectory	,
		SafelyMove
	)

Definition at line 152 of file TestUtilTest.cpp.

References folly::test::TemporaryDirectory::DELETE_ON_DESTRUCTION, expectTempdirExists(), and folly::gen::move.

                                     {
  std::unique_ptr<TemporaryDirectory> dir;
  TemporaryDirectory dir2;
  {
    auto scope = TemporaryDirectory::Scope::DELETE_ON_DESTRUCTION;
    TemporaryDirectory d("", "", scope);
    TemporaryDirectory d2("", "", scope);
    expectTempdirExists(d);
    expectTempdirExists(d2);

    dir = std::make_unique<TemporaryDirectory>(std::move(d));
    dir2 = std::move(d2);
  }

  expectTempdirExists(*dir);
  expectTempdirExists(dir2);
}

TEST	(	ChangeToTempDir	,
		ChangeDir
	)

Definition at line 170 of file TestUtilTest.cpp.

References EXPECT_EQ, and EXPECT_NE.

                                 {
  auto pwd1 = fs::current_path();
  {
    ChangeToTempDir d;
    EXPECT_NE(pwd1, fs::current_path());
  }
  EXPECT_EQ(pwd1, fs::current_path());
}

TEST	(	PCREPatternMatch	,
		Simple
	)

Definition at line 179 of file TestUtilTest.cpp.

References EXPECT_NO_PCRE_MATCH, and EXPECT_PCRE_MATCH.

                               {
  EXPECT_PCRE_MATCH(".*a.c.*", "gabca");
  EXPECT_NO_PCRE_MATCH("a.c", "gabca");
  EXPECT_NO_PCRE_MATCH(".*ac.*", "gabca");
}

TEST	(	CaptureFD	,
		GlogPatterns
	)

Definition at line 185 of file TestUtilTest.cpp.

References EXPECT_NO_PCRE_MATCH, EXPECT_PCRE_MATCH, folly::test::glogErrorPattern(), folly::test::glogErrOrWarnPattern(), folly::test::glogWarningPattern(), folly::INFO, folly::test::CaptureFD::readIncremental(), s, and folly::WARNING.

                              {
  CaptureFD err(fileno(stderr));
  LOG(INFO) << "All is well";
  EXPECT_NO_PCRE_MATCH(glogErrOrWarnPattern(), err.readIncremental());
  {
    LOG(ERROR) << "Uh-oh";
    auto s = err.readIncremental();
    EXPECT_PCRE_MATCH(glogErrorPattern(), s);
    EXPECT_NO_PCRE_MATCH(glogWarningPattern(), s);
    EXPECT_PCRE_MATCH(glogErrOrWarnPattern(), s);
  }
  {
    LOG(WARNING) << "Oops";
    auto s = err.readIncremental();
    EXPECT_NO_PCRE_MATCH(glogErrorPattern(), s);
    EXPECT_PCRE_MATCH(glogWarningPattern(), s);
    EXPECT_PCRE_MATCH(glogErrOrWarnPattern(), s);
  }
}

TEST	(	CaptureFD	,
		ChunkCob
	)

Definition at line 205 of file TestUtilTest.cpp.

References chunks, EXPECT_EQ, EXPECT_PCRE_MATCH, FAIL, folly::INFO, and folly::Range< Iter >::str().

                          {
  std::vector<std::string> chunks;
  {
    CaptureFD err(fileno(stderr), [&](StringPiece p) {
      chunks.emplace_back(p.str());
      switch (chunks.size()) {
        case 1:
          EXPECT_PCRE_MATCH(".*foo.*bar.*", p);
          break;
        case 2:
          EXPECT_PCRE_MATCH("[^\n]*baz.*", p);
          break;
        default:
          FAIL() << "Got too many chunks: " << chunks.size();
      }
    });
    LOG(INFO) << "foo";
    LOG(INFO) << "bar";
    EXPECT_PCRE_MATCH(".*foo.*bar.*", err.read());
    auto chunk = err.readIncremental();
    EXPECT_EQ(chunks.at(0), chunk);
    LOG(INFO) << "baz";
    EXPECT_PCRE_MATCH(".*foo.*bar.*baz.*", err.read());
  }
  EXPECT_EQ(2, chunks.size());
}

void testTemporaryDirectory

(

TemporaryDirectory::Scope

scope

)

Definition at line 116 of file TestUtilTest.cpp.

References folly::netops::close(), EXPECT_EQ, EXPECT_FALSE, EXPECT_NE, EXPECT_TRUE, f, folly::test::TemporaryDirectory::path(), and folly::test::TemporaryDirectory::PERMANENT.

Referenced by TEST().

                                                           {
  fs::path path;
  {
    TemporaryDirectory d("", "", scope);
    path = d.path();
    EXPECT_FALSE(path.empty());
    EXPECT_TRUE(path.is_absolute());
    EXPECT_TRUE(fs::exists(path));
    EXPECT_TRUE(fs::is_directory(path));

    fs::path fp = path / "bar";
    int fd = open(fp.string().c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666);
    EXPECT_NE(fd, -1);
    close(fd);

    TemporaryFile f("Foo", d.path());
    EXPECT_EQ(d.path(), f.path().parent_path());
  }
  bool exists = (scope == TemporaryDirectory::Scope::PERMANENT);
  EXPECT_EQ(exists, fs::exists(path));
}