FileTest.cpp File Reference

#include <folly/File.h>
#include <folly/String.h>
#include <folly/portability/Fcntl.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Macros
#define	EXPECT_CONTAINS(haystack, needle)

Functions
	TEST (File, Simple)
	TEST (File, SimpleStringPiece)
	TEST (File, OwnsFd)
	TEST (File, Release)
	TEST (File, UsefulError)
	TEST (File, Truthy)
	TEST (File, HelperCtor)

Macro Definition Documentation

#define EXPECT_CONTAINS	(		haystack,
			needle
	)

Value:

EXPECT_NE(::std::string::npos, ::folly::StringPiece(haystack).find(needle)) \
      << "Haystack: '" << haystack << "'\nNeedle: '" << needle << "'";

Definition at line 100 of file FileTest.cpp.

Referenced by TEST().

Function Documentation

TEST	(	File	,
		Simple
	)

Definition at line 37 of file FileTest.cpp.

References folly::File::close(), EXPECT_EQ, EXPECT_NE, f, folly::File::fd(), and fizz::detail::read().

                   {
  // Open a file, ensure it's indeed open for reading
  char buf = 'x';
  {
    File f("/etc/hosts");
    EXPECT_NE(-1, f.fd());
    EXPECT_EQ(1, ::read(f.fd(), &buf, 1));
    f.close();
    EXPECT_EQ(-1, f.fd());
  }
}

TEST	(	File	,
		SimpleStringPiece
	)

Definition at line 49 of file FileTest.cpp.

References folly::File::close(), EXPECT_EQ, EXPECT_NE, f, folly::File::fd(), and fizz::detail::read().

                              {
  char buf = 'x';
  File f(StringPiece("/etc/hosts"));
  EXPECT_NE(-1, f.fd());
  EXPECT_EQ(1, ::read(f.fd(), &buf, 1));
  f.close();
  EXPECT_EQ(-1, f.fd());
}

TEST	(	File	,
		OwnsFd
	)

Definition at line 58 of file FileTest.cpp.

References folly::netops::close(), EXPECT_EQ, f, folly::File::fd(), folly::gen::move, pipe(), and fizz::detail::read().

                   {
  // Wrap a file descriptor, make sure that ownsFd works
  // We'll test that the file descriptor is closed by closing the writing
  // end of a pipe and making sure that a non-blocking read from the reading
  // end returns 0.

  char buf = 'x';
  int p[2];
  expectOK(::pipe(p));
  int flags = ::fcntl(p[0], F_GETFL);
  expectOK(flags);
  expectOK(::fcntl(p[0], F_SETFL, flags | O_NONBLOCK));
  expectWouldBlock(::read(p[0], &buf, 1));
  {
    File f(p[1]);
    EXPECT_EQ(p[1], f.fd());
  }
  // Ensure that moving the file doesn't close it
  {
    File f(p[1]);
    EXPECT_EQ(p[1], f.fd());
    File f1(std::move(f));
    EXPECT_EQ(-1, f.fd());
    EXPECT_EQ(p[1], f1.fd());
  }
  expectWouldBlock(::read(p[0], &buf, 1)); // not closed
  {
    File f(p[1], true);
    EXPECT_EQ(p[1], f.fd());
  }
  ssize_t r = ::read(p[0], &buf, 1); // eof
  expectOK(r);
  EXPECT_EQ(0, r);
  ::close(p[0]);
}

TEST	(	File	,
		Release
	)

Definition at line 94 of file FileTest.cpp.

References folly::File::release().

                    {
  File in(STDOUT_FILENO, false);
  CHECK_EQ(STDOUT_FILENO, in.release());
  CHECK_EQ(-1, in.release());
}

TEST	(	File	,
		UsefulError
	)

Definition at line 104 of file FileTest.cpp.

References EXPECT_CONTAINS.

                        {
  try {
    File("does_not_exist.txt", 0, 0666);
  } catch (const std::runtime_error& e) {
    EXPECT_CONTAINS(e.what(), "does_not_exist.txt");
    EXPECT_CONTAINS(e.what(), "0666");
  }
}

TEST	(	File	,
		Truthy
	)

Definition at line 113 of file FileTest.cpp.

References ADD_FAILURE, EXPECT_FALSE, EXPECT_TRUE, shell_builder::temp, and folly::File::temporary().

                   {
  File temp = File::temporary();

  EXPECT_TRUE(bool(temp));

  if (temp) {
    ;
  } else {
    ADD_FAILURE();
  }

  if (File file = File::temporary()) {
    ;
  } else {
    ADD_FAILURE();
  }

  EXPECT_FALSE(bool(File()));
  if (File()) {
    ADD_FAILURE();
  }
  if (File notOpened = File()) {
    ADD_FAILURE();
  }
}

TEST	(	File	,
		HelperCtor
	)

Definition at line 139 of file FileTest.cpp.

References EXPECT_EQ, EXPECT_NE, f, folly::File::makeFile(), and fizz::detail::read().

                       {
  File::makeFile(StringPiece("/etc/hosts")).then([](File&& f) {
    char buf = 'x';
    EXPECT_NE(-1, f.fd());
    EXPECT_EQ(1, ::read(f.fd(), &buf, 1));
    f.close();
    EXPECT_EQ(-1, f.fd());
  });
}