SubprocessTest.cpp File Reference

#include <folly/Subprocess.h>
#include <sys/types.h>
#include <chrono>
#include <boost/container/flat_set.hpp>
#include <glog/logging.h>
#include <folly/Exception.h>
#include <folly/FileUtil.h>
#include <folly/Format.h>
#include <folly/String.h>
#include <folly/experimental/TestUtil.h>
#include <folly/experimental/io/FsUtil.h>
#include <folly/gen/Base.h>
#include <folly/gen/File.h>
#include <folly/gen/String.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>

Go to the source code of this file.

Classes
struct	WriteFileAfterFork

Macros
#define	EXPECT_SPAWN_OPT_ERROR(err, errMsg, options, cmd, ...)
#define	EXPECT_SPAWN_ERROR(err, errMsg, cmd, ...)   EXPECT_SPAWN_OPT_ERROR(err, errMsg, Subprocess::Options(), cmd, ##__VA_ARGS__)

Functions
	TEST (SimpleSubprocessTest, ExitsSuccessfully)
	TEST (SimpleSubprocessTest, ExitsSuccessfullyChecked)
	TEST (SimpleSubprocessTest, CloneFlagsWithVfork)
	TEST (SimpleSubprocessTest, CloneFlagsWithFork)
	TEST (SimpleSubprocessTest, CloneFlagsSubprocessCtorExitsAfterExec)
	TEST (SimpleSubprocessTest, ExitsWithError)
	TEST (SimpleSubprocessTest, ExitsWithErrorChecked)
	TEST (SimpleSubprocessTest, DefaultConstructibleProcessReturnCode)
	TEST (SimpleSubprocessTest, MoveSubprocess)
	TEST (SimpleSubprocessTest, DefaultConstructor)
	TEST (SimpleSubprocessTest, ExecFails)
	TEST (SimpleSubprocessTest, ShellExitsSuccesssfully)
	TEST (SimpleSubprocessTest, ShellExitsWithError)
	TEST (SimpleSubprocessTest, ChangeChildDirectorySuccessfully)
	TEST (SimpleSubprocessTest, ChangeChildDirectoryWithError)
	TEST (SimpleSubprocessTest, FdLeakTest)
	TEST (SimpleSubprocessTest, Detach)
	TEST (SimpleSubprocessTest, DetachExecFails)
	TEST (ParentDeathSubprocessTest, ParentDeathSignal)
	TEST (PopenSubprocessTest, PopenRead)
	TEST (AfterForkCallbackSubprocessTest, TestAfterForkCallbackSuccess)
	TEST (AfterForkCallbackSubprocessTest, TestAfterForkCallbackError)
	TEST (CommunicateSubprocessTest, SimpleRead)
	TEST (CommunicateSubprocessTest, BigWrite)
	TEST (CommunicateSubprocessTest, Duplex)
	TEST (CommunicateSubprocessTest, ProcessGroupLeader)
	TEST (CommunicateSubprocessTest, Duplex2)
	TEST (CommunicateSubprocessTest, Chatty)
	TEST (CommunicateSubprocessTest, TakeOwnershipOfPipes)

Macro Definition Documentation

#define EXPECT_SPAWN_ERROR	(		err,
			errMsg,
			cmd,
			...
	)		EXPECT_SPAWN_OPT_ERROR(err, errMsg, Subprocess::Options(), cmd, ##__VA_ARGS__)

Definition at line 128 of file SubprocessTest.cpp.

Referenced by TEST().

#define EXPECT_SPAWN_OPT_ERROR	(		err,
			errMsg,
			options,
			cmd,
			...
	)

Value:

do {                                                                \
    try {                                                             \
      Subprocess proc(                                                \
          std::vector<std::string>{(cmd), ##__VA_ARGS__}, (options)); \
      ADD_FAILURE() << "expected an error when running " << (cmd);    \
    } catch (const SubprocessSpawnError& ex) {                        \
      EXPECT_EQ((err), ex.errnoValue());                              \
      if (StringPiece(ex.what()).find(errMsg) == StringPiece::npos) { \
        ADD_FAILURE() << "failed to find \"" << (errMsg)              \
                      << "\" in exception: \"" << ex.what() << "\"";  \
      }                                                               \
    }                                                                 \
  } while (0)

Definition at line 113 of file SubprocessTest.cpp.

Referenced by TEST().

Function Documentation

TEST	(	SimpleSubprocessTest	,
		ExitsSuccessfully
	)

Definition at line 42 of file SubprocessTest.cpp.

References EXPECT_EQ.

                                              {
  Subprocess proc(std::vector<std::string>{"/bin/true"});
  EXPECT_EQ(0, proc.wait().exitStatus());
}

TEST	(	SimpleSubprocessTest	,
		ExitsSuccessfullyChecked
	)

Definition at line 47 of file SubprocessTest.cpp.

References folly::Subprocess::waitChecked().

                                                     {
  Subprocess proc(std::vector<std::string>{"/bin/true"});
  proc.waitChecked();
}

TEST	(	SimpleSubprocessTest	,
		CloneFlagsWithVfork
	)

Definition at line 52 of file SubprocessTest.cpp.

References EXPECT_EQ.

                                                {
  Subprocess proc(
      std::vector<std::string>{"/bin/true"},
      Subprocess::Options().useCloneWithFlags(SIGCHLD | CLONE_VFORK));
  EXPECT_EQ(0, proc.wait().exitStatus());
}

TEST	(	SimpleSubprocessTest	,
		CloneFlagsWithFork
	)

Definition at line 59 of file SubprocessTest.cpp.

References EXPECT_EQ.

                                               {
  Subprocess proc(
      std::vector<std::string>{"/bin/true"},
      Subprocess::Options().useCloneWithFlags(SIGCHLD));
  EXPECT_EQ(0, proc.wait().exitStatus());
}

TEST	(	SimpleSubprocessTest	,
		CloneFlagsSubprocessCtorExitsAfterExec
	)

Definition at line 66 of file SubprocessTest.cpp.

References folly::checkUnixError(), and EXPECT_TRUE.

                                                                   {
  Subprocess proc(
      std::vector<std::string>{"/bin/sleep", "3600"},
      Subprocess::Options().useCloneWithFlags(SIGCHLD));
  checkUnixError(::kill(proc.pid(), SIGKILL), "kill");
  auto retCode = proc.wait();
  EXPECT_TRUE(retCode.killed());
}

TEST	(	SimpleSubprocessTest	,
		ExitsWithError
	)

Definition at line 75 of file SubprocessTest.cpp.

References EXPECT_EQ.

                                           {
  Subprocess proc(std::vector<std::string>{"/bin/false"});
  EXPECT_EQ(1, proc.wait().exitStatus());
}

TEST	(	SimpleSubprocessTest	,
		ExitsWithErrorChecked
	)

Definition at line 80 of file SubprocessTest.cpp.

References EXPECT_THROW.

                                                  {
  Subprocess proc(std::vector<std::string>{"/bin/false"});
  EXPECT_THROW(proc.waitChecked(), CalledProcessError);
}

TEST	(	SimpleSubprocessTest	,
		DefaultConstructibleProcessReturnCode
	)

Definition at line 85 of file SubprocessTest.cpp.

References EXPECT_TRUE, and folly::ProcessReturnCode::notStarted().

                                                                  {
  ProcessReturnCode retcode;
  EXPECT_TRUE(retcode.notStarted());
}

TEST	(	SimpleSubprocessTest	,
		MoveSubprocess
	)

Definition at line 90 of file SubprocessTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and folly::gen::move.

                                           {
  Subprocess old_proc(std::vector<std::string>{"/bin/true"});
  EXPECT_TRUE(old_proc.returnCode().running());
  auto new_proc = std::move(old_proc);
  EXPECT_TRUE(old_proc.returnCode().notStarted());
  EXPECT_TRUE(new_proc.returnCode().running());
  EXPECT_EQ(0, new_proc.wait().exitStatus());
  // Now old_proc is destroyed, but we don't crash.
}

TEST	(	SimpleSubprocessTest	,
		DefaultConstructor
	)

Definition at line 100 of file SubprocessTest.cpp.

References folly::ProcessReturnCode::exitStatus(), EXPECT_EQ, EXPECT_TRUE, folly::gen::move, folly::ProcessReturnCode::notStarted(), folly::Subprocess::returnCode(), folly::ProcessReturnCode::running(), gmock_test_utils::Subprocess, and folly::Subprocess::wait().

                                               {
  Subprocess proc;
  EXPECT_TRUE(proc.returnCode().notStarted());

  {
    auto p1 = Subprocess(std::vector<std::string>{"/bin/true"});
    proc = std::move(p1);
  }

  EXPECT_TRUE(proc.returnCode().running());
  EXPECT_EQ(0, proc.wait().exitStatus());
}

TEST	(	SimpleSubprocessTest	,
		ExecFails
	)

Definition at line 131 of file SubprocessTest.cpp.

References EXPECT_SPAWN_ERROR.

                                      {
  EXPECT_SPAWN_ERROR(
      ENOENT, "failed to execute /no/such/file:", "/no/such/file");
  EXPECT_SPAWN_ERROR(EACCES, "failed to execute /etc/passwd:", "/etc/passwd");
  EXPECT_SPAWN_ERROR(
      ENOTDIR,
      "failed to execute /etc/passwd/not/a/file:",
      "/etc/passwd/not/a/file");
}

TEST	(	SimpleSubprocessTest	,
		ShellExitsSuccesssfully
	)

Definition at line 141 of file SubprocessTest.cpp.

References folly::ProcessReturnCode::exitStatus(), EXPECT_EQ, and folly::Subprocess::wait().

                                                    {
  Subprocess proc("true");
  EXPECT_EQ(0, proc.wait().exitStatus());
}

TEST	(	SimpleSubprocessTest	,
		ShellExitsWithError
	)

Definition at line 146 of file SubprocessTest.cpp.

References folly::ProcessReturnCode::exitStatus(), EXPECT_EQ, and folly::Subprocess::wait().

                                                {
  Subprocess proc("false");
  EXPECT_EQ(1, proc.wait().exitStatus());
}

TEST	(	SimpleSubprocessTest	,
		ChangeChildDirectorySuccessfully
	)

Definition at line 151 of file SubprocessTest.cpp.

References folly::ProcessReturnCode::exitStatus(), EXPECT_EQ, EXPECT_SPAWN_ERROR, and folly::Subprocess::wait().

                                                             {
  // The filesystem root normally lacks a 'true' binary
  EXPECT_EQ(0, chdir("/"));
  EXPECT_SPAWN_ERROR(ENOENT, "failed to execute ./true", "./true");
  // The child can fix that by moving to /bin before exec().
  Subprocess proc("./true", Subprocess::Options().chdir("/bin"));
  EXPECT_EQ(0, proc.wait().exitStatus());
}

TEST	(	SimpleSubprocessTest	,
		ChangeChildDirectoryWithError
	)

Definition at line 160 of file SubprocessTest.cpp.

References ADD_FAILURE, folly::Subprocess::Options::chdir(), folly::SubprocessSpawnError::errnoValue(), EXPECT_EQ, and string.

                                                          {
  try {
    Subprocess proc(
        std::vector<std::string>{"/bin/true"},
        Subprocess::Options().chdir("/usually/this/is/not/a/valid/directory/"));
    ADD_FAILURE() << "expected to fail when changing the child's directory";
  } catch (const SubprocessSpawnError& ex) {
    EXPECT_EQ(ENOENT, ex.errnoValue());
    const std::string expectedError =
        "error preparing to execute /bin/true: No such file or directory";
    if (StringPiece(ex.what()).find(expectedError) == StringPiece::npos) {
      ADD_FAILURE() << "failed to find \"" << expectedError
                    << "\" in exception: \"" << ex.what() << "\"";
    }
  }
}

TEST	(	SimpleSubprocessTest	,
		FdLeakTest
	)

Definition at line 206 of file SubprocessTest.cpp.

References ADD_FAILURE, folly::Subprocess::communicate(), folly::SubprocessSpawnError::errnoValue(), folly::ProcessReturnCode::exitStatus(), EXPECT_EQ, EXPECT_SPAWN_ERROR, folly::Subprocess::wait(), and folly::Subprocess::waitChecked().

                                       {
  // Normal execution
  checkFdLeak([] {
    Subprocess proc("true");
    EXPECT_EQ(0, proc.wait().exitStatus());
  });
  // Normal execution with pipes
  checkFdLeak([] {
    Subprocess proc(
        "echo foo; echo bar >&2",
        Subprocess::Options().pipeStdout().pipeStderr());
    auto p = proc.communicate();
    EXPECT_EQ("foo\n", p.first);
    EXPECT_EQ("bar\n", p.second);
    proc.waitChecked();
  });

  // Test where the exec call fails()
  checkFdLeak(
      [] { EXPECT_SPAWN_ERROR(ENOENT, "failed to execute", "/no/such/file"); });
  // Test where the exec call fails() with pipes
  checkFdLeak([] {
    try {
      Subprocess proc(
          std::vector<std::string>({"/no/such/file"}),
          Subprocess::Options().pipeStdout().stderrFd(Subprocess::PIPE));
      ADD_FAILURE() << "expected an error when running /no/such/file";
    } catch (const SubprocessSpawnError& ex) {
      EXPECT_EQ(ENOENT, ex.errnoValue());
    }
  });
}

TEST	(	SimpleSubprocessTest	,
		Detach
	)

Definition at line 239 of file SubprocessTest.cpp.

References folly::Subprocess::Options::detach(), folly::test::end(), EXPECT_EQ, EXPECT_LE, now(), s, and start.

                                   {
  auto start = std::chrono::steady_clock::now();
  {
    Subprocess proc(
        std::vector<std::string>{"/bin/sleep", "10"},
        Subprocess::Options().detach());
    EXPECT_EQ(-1, proc.pid());
  }
  auto end = std::chrono::steady_clock::now();
  // We should be able to create and destroy the Subprocess object quickly,
  // without waiting for the sleep process to finish.  This should usually
  // happen in a matter of milliseconds, but we allow up to 5 seconds just to
  // provide lots of leeway on heavily loaded continuous build machines.
  EXPECT_LE(end - start, 5s);
}

TEST	(	SimpleSubprocessTest	,
		DetachExecFails
	)

Definition at line 255 of file SubprocessTest.cpp.

References EXPECT_SPAWN_OPT_ERROR.

                                            {
  // Errors executing the process should be propagated from the grandchild
  // process back to the original parent process.
  EXPECT_SPAWN_OPT_ERROR(
      ENOENT,
      "failed to execute /no/such/file:",
      Subprocess::Options().detach(),
      "/no/such/file");
}

TEST	(	ParentDeathSubprocessTest	,
		ParentDeathSignal
	)

Definition at line 265 of file SubprocessTest.cpp.

References ASSERT_EQ, folly::fs::executable_path(), folly::ProcessReturnCode::killSignal(), and folly::Subprocess::wait().

                                                   {
  // Find out where we are.
  const auto basename = "subprocess_test_parent_death_helper";
  auto helper = fs::executable_path();
  helper.remove_filename() /= basename;
  if (!fs::exists(helper)) {
    helper = helper.parent_path().parent_path() / basename / basename;
  }

  fs::path tempFile(fs::temp_directory_path() / fs::unique_path());

  std::vector<std::string> args{helper.string(), tempFile.string()};
  Subprocess proc(args);
  // The helper gets killed by its child, see details in
  // SubprocessTestParentDeathHelper.cpp
  ASSERT_EQ(SIGKILL, proc.wait().killSignal());

  // Now wait for the file to be created, see details in
  // SubprocessTestParentDeathHelper.cpp
  while (!fs::exists(tempFile)) {
    usleep(20000); // 20ms
  }

  fs::remove(tempFile);
}

TEST	(	PopenSubprocessTest	,
		PopenRead
	)

Definition at line 291 of file SubprocessTest.cpp.

References folly::gen::byLine(), EXPECT_EQ, folly::Subprocess::stdoutFd(), and folly::Subprocess::waitChecked().

                                     {
  Subprocess proc("ls /", Subprocess::Options().pipeStdout());
  int found = 0;
  gen::byLine(File(proc.stdoutFd())) | [&](StringPiece line) {
    if (line == "etc" || line == "bin" || line == "usr") {
      ++found;
    }
  };
  EXPECT_EQ(3, found);
  proc.waitChecked();
}

TEST	(	AfterForkCallbackSubprocessTest	,
		TestAfterForkCallbackSuccess
	)

Definition at line 320 of file SubprocessTest.cpp.

References folly::Subprocess::Options::dangerousPostForkPreExecCallback(), EXPECT_EQ, EXPECT_TRUE, WriteFileAfterFork::filename_, folly::readFile(), s, and string.

                                                                    {
  test::ChangeToTempDir td;
  // Trigger a file write from the child.
  WriteFileAfterFork write_cob("good_file");
  Subprocess proc(
      std::vector<std::string>{"/bin/echo"},
      Subprocess::Options().dangerousPostForkPreExecCallback(&write_cob));
  // The file gets written immediately.
  std::string s;
  EXPECT_TRUE(readFile(write_cob.filename_.c_str(), s));
  EXPECT_EQ("ok", s);
  proc.waitChecked();
}

TEST	(	AfterForkCallbackSubprocessTest	,
		TestAfterForkCallbackError
	)

Definition at line 334 of file SubprocessTest.cpp.

References folly::Subprocess::Options::dangerousPostForkPreExecCallback(), EXPECT_FALSE, EXPECT_THROW, and WriteFileAfterFork::filename_.

                                                                  {
  test::ChangeToTempDir td;
  // The child will try to write to a file, whose directory does not exist.
  WriteFileAfterFork write_cob("bad/file");
  EXPECT_THROW(
      Subprocess proc(
          std::vector<std::string>{"/bin/echo"},
          Subprocess::Options().dangerousPostForkPreExecCallback(&write_cob)),
      SubprocessSpawnError);
  EXPECT_FALSE(fs::exists(write_cob.filename_));
}

TEST	(	CommunicateSubprocessTest	,
		SimpleRead
	)

Definition at line 346 of file SubprocessTest.cpp.

References folly::Subprocess::communicate(), EXPECT_EQ, and folly::Subprocess::Options::pipeStdout().

                                            {
  Subprocess proc(
      std::vector<std::string>{"/bin/echo", "-n", "foo", "bar"},
      Subprocess::Options().pipeStdout());
  auto p = proc.communicate();
  EXPECT_EQ("foo bar", p.first);
  proc.waitChecked();
}

TEST	(	CommunicateSubprocessTest	,
		BigWrite
	)

Definition at line 355 of file SubprocessTest.cpp.

References folly::Subprocess::communicate(), data, EXPECT_EQ, folly::format(), i, string, and folly::Subprocess::waitChecked().

                                          {
  const int numLines = 1 << 20;
  std::string line("hello\n");
  std::string data;
  data.reserve(numLines * line.size());
  for (int i = 0; i < numLines; ++i) {
    data.append(line);
  }

  Subprocess proc("wc -l", Subprocess::Options().pipeStdin().pipeStdout());
  auto p = proc.communicate(data);
  EXPECT_EQ(folly::format("{}\n", numLines).str(), p.first);
  proc.waitChecked();
}

TEST	(	CommunicateSubprocessTest	,
		Duplex
	)

Definition at line 370 of file SubprocessTest.cpp.

References folly::Subprocess::communicate(), EXPECT_EQ, string, and folly::Subprocess::waitChecked().

                                        {
  // Take 10MB of data and pass them through a filter.
  // One line, as tr is line-buffered
  const int bytes = 10 << 20;
  std::string line(bytes, 'x');

  Subprocess proc("tr a-z A-Z", Subprocess::Options().pipeStdin().pipeStdout());
  auto p = proc.communicate(line);
  EXPECT_EQ(bytes, p.first.size());
  EXPECT_EQ(std::string::npos, p.first.find_first_not_of('X'));
  proc.waitChecked();
}

TEST	(	CommunicateSubprocessTest	,
		ProcessGroupLeader
	)

Definition at line 383 of file SubprocessTest.cpp.

References EXPECT_THROW, and folly::Subprocess::waitChecked().

                                                    {
  const auto testIsLeader = "test $(cut -d ' ' -f 5 /proc/$$/stat) = $$";
  Subprocess nonLeader(testIsLeader);
  EXPECT_THROW(nonLeader.waitChecked(), CalledProcessError);
  Subprocess leader(testIsLeader, Subprocess::Options().processGroupLeader());
  leader.waitChecked();
}

TEST	(	CommunicateSubprocessTest	,
		Duplex2
	)

Definition at line 391 of file SubprocessTest.cpp.

References folly::IOBufQueue::append(), cmd, folly::Subprocess::communicateIOBuf(), fizz::test::copyBuffer(), upload::dest, EXPECT_EQ, folly::gen::move, folly::Subprocess::Options::pipeStderr(), folly::Subprocess::Options::pipeStdin(), folly::Subprocess::Options::pipeStdout(), fizz::detail::read(), folly::gen::split(), string, folly::Subprocess::Options::usePath(), and folly::Subprocess::waitChecked().

                                         {
  checkFdLeak([] {
    // Pipe 200,000 lines through sed
    const size_t numCopies = 100000;
    auto iobuf = IOBuf::copyBuffer("this is a test\nanother line\n");
    IOBufQueue input;
    for (size_t n = 0; n < numCopies; ++n) {
      input.append(iobuf->clone());
    }

    std::vector<std::string> cmd({
        "sed",
        "-u",
        "-e",
        "s/a test/a successful test/",
        "-e",
        "/^another line/w/dev/stderr",
    });
    auto options =
        Subprocess::Options().pipeStdin().pipeStdout().pipeStderr().usePath();
    Subprocess proc(cmd, options);
    auto out = proc.communicateIOBuf(std::move(input));
    proc.waitChecked();

    // Convert stdout and stderr to strings so we can call split() on them.
    fbstring stdoutStr;
    if (out.first.front()) {
      stdoutStr = out.first.move()->moveToFbString();
    }
    fbstring stderrStr;
    if (out.second.front()) {
      stderrStr = out.second.move()->moveToFbString();
    }

    // stdout should be a copy of stdin, with "a test" replaced by
    // "a successful test"
    std::vector<StringPiece> stdoutLines;
    split('\n', stdoutStr, stdoutLines);
    EXPECT_EQ(numCopies * 2 + 1, stdoutLines.size());
    // Strip off the trailing empty line
    if (!stdoutLines.empty()) {
      EXPECT_EQ("", stdoutLines.back());
      stdoutLines.pop_back();
    }
    size_t linenum = 0;
    for (const auto& line : stdoutLines) {
      if ((linenum & 1) == 0) {
        EXPECT_EQ("this is a successful test", line);
      } else {
        EXPECT_EQ("another line", line);
      }
      ++linenum;
    }

    // stderr should only contain the lines containing "another line"
    std::vector<StringPiece> stderrLines;
    split('\n', stderrStr, stderrLines);
    EXPECT_EQ(numCopies + 1, stderrLines.size());
    // Strip off the trailing empty line
    if (!stderrLines.empty()) {
      EXPECT_EQ("", stderrLines.back());
      stderrLines.pop_back();
    }
    for (const auto& line : stderrLines) {
      EXPECT_EQ("another line", line);
    }
  });
}

TEST	(	CommunicateSubprocessTest	,
		Chatty
	)

Definition at line 491 of file SubprocessTest.cpp.

References cmd, folly::Subprocess::communicate(), folly::Subprocess::enableNotifications(), folly::ProcessReturnCode::exitStatus(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::Subprocess::Options::pipeStderr(), folly::Subprocess::Options::pipeStdin(), folly::Subprocess::Options::pipeStdout(), string, folly::Subprocess::Options::usePath(), folly::Subprocess::wait(), and folly::writeFull().

                                        {
  checkFdLeak([] {
    const int lineCount = 1000;

    int wcount = 0;
    int rcount = 0;

    auto options =
        Subprocess::Options().pipeStdin().pipeStdout().pipeStderr().usePath();
    std::vector<std::string> cmd{
        "sed",
        "-u",
        "-e",
        "s/a test/a successful test/",
    };

    Subprocess proc(cmd, options);

    auto writeCallback = [&](int pfd, int cfd) -> bool {
      EXPECT_EQ(0, cfd); // child stdin
      EXPECT_EQ(rcount, wcount); // chatty, one read for every write

      auto msg = folly::to<std::string>("a test ", wcount, "\n");

      // Not entirely kosher, we should handle partial writes, but this is
      // fine for writes <= PIPE_BUF
      EXPECT_EQ(msg.size(), writeFull(pfd, msg.data(), msg.size()));

      ++wcount;
      proc.enableNotifications(0, false);

      return (wcount == lineCount);
    };

    bool eofSeen = false;

    auto readCallback = [&](int pfd, int cfd) -> bool {
      std::string lineBuf;

      if (cfd != 1) {
        EXPECT_EQ(2, cfd);
        EXPECT_TRUE(readToString(pfd, lineBuf, 1));
        EXPECT_EQ(0, lineBuf.size());
        return true;
      }

      EXPECT_FALSE(eofSeen);

      std::string expected;

      if (rcount < lineCount) {
        expected = folly::to<std::string>("a successful test ", rcount++, "\n");
      }

      EXPECT_EQ(wcount, rcount);

      // Not entirely kosher, we should handle partial reads, but this is
      // fine for reads <= PIPE_BUF
      bool atEof = readToString(pfd, lineBuf, expected.size() + 1);
      if (atEof) {
        // EOF only expected after we finished reading
        EXPECT_EQ(lineCount, rcount);
        eofSeen = true;
      }

      EXPECT_EQ(expected, lineBuf);

      if (wcount != lineCount) { // still more to write...
        proc.enableNotifications(0, true);
      }

      return eofSeen;
    };

    proc.communicate(readCallback, writeCallback);

    EXPECT_EQ(lineCount, wcount);
    EXPECT_EQ(lineCount, rcount);
    EXPECT_TRUE(eofSeen);

    EXPECT_EQ(0, proc.wait().exitStatus());
  });
}

TEST	(	CommunicateSubprocessTest	,
		TakeOwnershipOfPipes
	)

Definition at line 575 of file SubprocessTest.cpp.

References EXPECT_EQ, pipe(), folly::readFull(), string, folly::Subprocess::takeOwnershipOfPipes(), and folly::Subprocess::waitChecked().

                                                      {
  std::vector<Subprocess::ChildPipe> pipes;
  {
    Subprocess proc(
        "echo $'oh\\nmy\\ncat' | wc -l &", Subprocess::Options().pipeStdout());
    pipes = proc.takeOwnershipOfPipes();
    proc.waitChecked();
  }
  EXPECT_EQ(1, pipes.size());
  EXPECT_EQ(1, pipes[0].childFd);

  char buf[10];
  EXPECT_EQ(2, readFull(pipes[0].pipe.fd(), buf, 10));
  buf[2] = 0;
  EXPECT_EQ("3\n", std::string(buf));
}