v811_spc009/external/libbrillo/brillo/files/safe_fd_test.cc

// Copyright 2019 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "brillo/files/safe_fd.h"

#include <fcntl.h>
#include <sys/stat.h>

#include <base/files/file_util.h>
#include <brillo/files/file_util_test.h>
#include <brillo/syslog_logging.h>
#include <gtest/gtest.h>

namespace brillo {

class SafeFDTest : public FileTest {};

TEST_F(SafeFDTest, SafeFD) {
  EXPECT_FALSE(SafeFD().is_valid());
}

TEST_F(SafeFDTest, SafeFD_Move) {
  SafeFD moved_root = std::move(root_);
  EXPECT_FALSE(root_.is_valid());
  ASSERT_TRUE(moved_root.is_valid());

  SafeFD moved_root2(std::move(moved_root));
  EXPECT_FALSE(moved_root.is_valid());
  ASSERT_TRUE(moved_root2.is_valid());
}

TEST_F(SafeFDTest, Root) {
  SafeFD::SafeFDResult result = SafeFD::Root();
  EXPECT_TRUE(result.first.is_valid());
  EXPECT_EQ(result.second, SafeFD::Error::kNoError);
}

TEST_F(SafeFDTest, reset) {
  root_.reset();
  EXPECT_FALSE(root_.is_valid());
}

TEST_F(SafeFDTest, UnsafeReset) {
  int fd =
      HANDLE_EINTR(open(temp_dir_path_.data(),
                        O_NONBLOCK | O_DIRECTORY | O_RDONLY | O_CLOEXEC, 0777));
  ASSERT_GE(fd, 0);

  {
    SafeFD safe_fd;
    safe_fd.UnsafeReset(fd);
    EXPECT_EQ(safe_fd.get(), fd);
  }

  // Verify the file descriptor is closed.
  int result = fcntl(fd, F_GETFD);
  int error = errno;
  EXPECT_EQ(result, -1);
  EXPECT_EQ(error, EBADF);
}

TEST_F(SafeFDTest, Write_Success) {
  std::string random_data = GetRandomSuffix();
  {
    SafeFD::SafeFDResult file = root_.MakeFile(file_path_);
    EXPECT_EQ(file.second, SafeFD::Error::kNoError);
    ASSERT_TRUE(file.first.is_valid());

    EXPECT_EQ(file.first.Write(random_data.data(), random_data.size()),
              SafeFD::Error::kNoError);
  }

  ExpectFileContains(random_data);
  ExpectPermissions(file_path_, SafeFD::kDefaultFilePermissions);
}

TEST_F(SafeFDTest, Write_NotInitialized) {
  SafeFD invalid;
  ASSERT_FALSE(invalid.is_valid());

  std::string random_data = GetRandomSuffix();
  EXPECT_EQ(invalid.Write(random_data.data(), random_data.size()),
            SafeFD::Error::kNotInitialized);
}

TEST_F(SafeFDTest, Write_VerifyTruncate) {
  std::string random_data = GetRandomSuffix();
  ASSERT_TRUE(WriteFile(random_data));

  {
    SafeFD::SafeFDResult file = root_.OpenExistingFile(file_path_);
    EXPECT_EQ(file.second, SafeFD::Error::kNoError);
    ASSERT_TRUE(file.first.is_valid());

    EXPECT_EQ(file.first.Write("", 0), SafeFD::Error::kNoError);
  }

  ExpectFileContains("");
}

TEST_F(SafeFDTest, Write_Failure) {
  std::string random_data = GetRandomSuffix();
  EXPECT_EQ(root_.Write("", 1), SafeFD::Error::kIOError);
}

TEST_F(SafeFDTest, ReadContents_Success) {
  std::string random_data = GetRandomSuffix();
  ASSERT_TRUE(WriteFile(random_data));

  SafeFD::SafeFDResult file = root_.OpenExistingFile(file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kNoError);
  ASSERT_TRUE(file.first.is_valid());

  auto result = file.first.ReadContents();
  EXPECT_EQ(result.second, SafeFD::Error::kNoError);
  ASSERT_EQ(random_data.size(), result.first.size());
  EXPECT_EQ(memcmp(random_data.data(), result.first.data(), random_data.size()),
            0);
}

TEST_F(SafeFDTest, ReadContents_ExceededMaximum) {
  std::string random_data = GetRandomSuffix();
  ASSERT_TRUE(WriteFile(random_data));

  SafeFD::SafeFDResult file = root_.OpenExistingFile(file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kNoError);
  ASSERT_TRUE(file.first.is_valid());

  ASSERT_LT(1, random_data.size());
  auto result = file.first.ReadContents(1);
  EXPECT_EQ(result.second, SafeFD::Error::kExceededMaximum);
}

TEST_F(SafeFDTest, ReadContents_NotInitialized) {
  SafeFD invalid;
  ASSERT_FALSE(invalid.is_valid());

  auto result = invalid.ReadContents();
  EXPECT_EQ(result.second, SafeFD::Error::kNotInitialized);
}

TEST_F(SafeFDTest, Read_Success) {
  std::string random_data = GetRandomSuffix();
  ASSERT_TRUE(WriteFile(random_data));

  SafeFD::SafeFDResult file = root_.OpenExistingFile(file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kNoError);
  ASSERT_TRUE(file.first.is_valid());

  std::vector<char> buffer(random_data.size(), '\0');
  ASSERT_EQ(file.first.Read(buffer.data(), buffer.size()),
            SafeFD::Error::kNoError);
  EXPECT_EQ(memcmp(random_data.data(), buffer.data(), random_data.size()), 0);
}

TEST_F(SafeFDTest, Read_NotInitialized) {
  SafeFD invalid;
  ASSERT_FALSE(invalid.is_valid());

  char to_read;
  EXPECT_EQ(invalid.Read(&to_read, 1), SafeFD::Error::kNotInitialized);
}

TEST_F(SafeFDTest, Read_IOError) {
  std::string random_data = GetRandomSuffix();
  ASSERT_TRUE(WriteFile(random_data));

  SafeFD::SafeFDResult file = root_.OpenExistingFile(file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kNoError);
  ASSERT_TRUE(file.first.is_valid());

  std::vector<char> buffer(random_data.size() * 2, '\0');
  ASSERT_EQ(file.first.Read(buffer.data(), buffer.size()),
            SafeFD::Error::kIOError);
}

TEST_F(SafeFDTest, OpenExistingFile_Success) {
  std::string data = GetRandomSuffix();
  ASSERT_TRUE(WriteFile(data));
  {
    SafeFD::SafeFDResult file = root_.OpenExistingFile(file_path_);
    EXPECT_EQ(file.second, SafeFD::Error::kNoError);
    ASSERT_TRUE(file.first.is_valid());
  }
  ExpectFileContains(data);
}

TEST_F(SafeFDTest, OpenExistingFile_NotInitialized) {
  SafeFD::SafeFDResult file = SafeFD().OpenExistingFile(file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kNotInitialized);
  ASSERT_FALSE(file.first.is_valid());
}

TEST_F(SafeFDTest, OpenExistingFile_DoesNotExist) {
  SafeFD::SafeFDResult file = root_.OpenExistingFile(file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kDoesNotExist);
  ASSERT_FALSE(file.first.is_valid());
}

TEST_F(SafeFDTest, OpenExistingFile_IOError) {
  ASSERT_TRUE(WriteFile(""));
  EXPECT_EQ(chmod(file_path_.value().c_str(), 0000), 0) << strerror(errno);

  SafeFD::SafeFDResult file = root_.OpenExistingFile(file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kIOError);
  ASSERT_FALSE(file.first.is_valid());
}

TEST_F(SafeFDTest, OpenExistingFile_SymlinkDetected) {
  ASSERT_TRUE(SetupSymlinks());
  ASSERT_TRUE(WriteFile(""));
  SafeFD::SafeFDResult file = root_.OpenExistingFile(symlink_file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kSymlinkDetected);
  ASSERT_FALSE(file.first.is_valid());
}

TEST_F(SafeFDTest, OpenExistingFile_WrongType) {
  ASSERT_TRUE(SetupSymlinks());
  ASSERT_TRUE(WriteFile(""));
  SafeFD::SafeFDResult file =
      root_.OpenExistingFile(symlink_dir_path_.Append(kFileName));
  EXPECT_EQ(file.second, SafeFD::Error::kWrongType);
  ASSERT_FALSE(file.first.is_valid());
}

TEST_F(SafeFDTest, OpenExistingDir_Success) {
  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  EXPECT_EQ(dir.second, SafeFD::Error::kNoError);
  ASSERT_TRUE(dir.first.is_valid());
}

TEST_F(SafeFDTest, OpenExistingDir_NotInitialized) {
  SafeFD::SafeFDResult dir = SafeFD().OpenExistingDir(temp_dir_.GetPath());
  EXPECT_EQ(dir.second, SafeFD::Error::kNotInitialized);
  ASSERT_FALSE(dir.first.is_valid());
}

TEST_F(SafeFDTest, OpenExistingDir_DoesNotExist) {
  SafeFD::SafeFDResult dir = root_.OpenExistingDir(sub_dir_path_);
  EXPECT_EQ(dir.second, SafeFD::Error::kDoesNotExist);
  ASSERT_FALSE(dir.first.is_valid());
}

TEST_F(SafeFDTest, OpenExistingDir_IOError) {
  ASSERT_TRUE(WriteFile(""));
  ASSERT_EQ(chmod(sub_dir_path_.value().c_str(), 0000), 0) << strerror(errno);

  SafeFD::SafeFDResult dir = root_.OpenExistingDir(sub_dir_path_);
  EXPECT_EQ(dir.second, SafeFD::Error::kIOError);
  ASSERT_FALSE(dir.first.is_valid());
}

TEST_F(SafeFDTest, OpenExistingDir_WrongType) {
  ASSERT_TRUE(SetupSymlinks());
  SafeFD::SafeFDResult dir = root_.OpenExistingDir(symlink_dir_path_);
  EXPECT_EQ(dir.second, SafeFD::Error::kWrongType);
  ASSERT_FALSE(dir.first.is_valid());
}

TEST_F(SafeFDTest, MakeFile_DoesNotExistSuccess) {
  {
    SafeFD::SafeFDResult file = root_.MakeFile(file_path_);
    EXPECT_EQ(file.second, SafeFD::Error::kNoError);
    ASSERT_TRUE(file.first.is_valid());
  }

  ExpectPermissions(file_path_, SafeFD::kDefaultFilePermissions);
}

TEST_F(SafeFDTest, MakeFile_LeadingSelfDirSuccess) {
  ASSERT_TRUE(SetupSubdir());

  SafeFD::Error err;
  SafeFD dir;
  std::tie(dir, err) = root_.OpenExistingDir(sub_dir_path_);
  ASSERT_EQ(err, SafeFD::Error::kNoError);

  {
    SafeFD file;
    std::tie(file, err) = dir.MakeFile(file_path_.BaseName());
    EXPECT_EQ(err, SafeFD::Error::kNoError);
    ASSERT_TRUE(file.is_valid());
  }

  ExpectPermissions(file_path_, SafeFD::kDefaultFilePermissions);
}

TEST_F(SafeFDTest, MakeFile_ExistsSuccess) {
  std::string data = GetRandomSuffix();
  ASSERT_TRUE(WriteFile(data));
  {
    SafeFD::SafeFDResult file = root_.MakeFile(file_path_);
    EXPECT_EQ(file.second, SafeFD::Error::kNoError);
    ASSERT_TRUE(file.first.is_valid());
  }
  ExpectPermissions(file_path_, SafeFD::kDefaultFilePermissions);
  ExpectFileContains(data);
}

TEST_F(SafeFDTest, MakeFile_IOError) {
  ASSERT_TRUE(SetupSubdir());
  ASSERT_EQ(mkfifo(file_path_.value().c_str(), 0), 0);
  SafeFD::SafeFDResult file = root_.MakeFile(file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kIOError);
  ASSERT_FALSE(file.first.is_valid());
}

TEST_F(SafeFDTest, MakeFile_SymlinkDetected) {
  ASSERT_TRUE(SetupSymlinks());
  SafeFD::SafeFDResult file = root_.MakeFile(symlink_file_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kSymlinkDetected);
  ASSERT_FALSE(file.first.is_valid());
}

TEST_F(SafeFDTest, MakeFile_WrongType) {
  ASSERT_TRUE(SetupSubdir());
  SafeFD::SafeFDResult file = root_.MakeFile(sub_dir_path_);
  EXPECT_EQ(file.second, SafeFD::Error::kWrongType);
  ASSERT_FALSE(file.first.is_valid());
}

TEST_F(SafeFDTest, MakeFile_WrongGID) {
  ASSERT_TRUE(WriteFile(""));
  ASSERT_EQ(chown(file_path_.value().c_str(), getuid(), 0), 0)
      << strerror(errno);
  {
    SafeFD::SafeFDResult file = root_.MakeFile(file_path_);
    EXPECT_EQ(file.second, SafeFD::Error::kWrongGID);
    ASSERT_FALSE(file.first.is_valid());
  }
}

TEST_F(SafeFDTest, MakeFile_WrongPermissions) {
  ASSERT_TRUE(WriteFile(""));
  ASSERT_EQ(chmod(file_path_.value().c_str(), 0777), 0) << strerror(errno);
  {
    SafeFD::SafeFDResult file = root_.MakeFile(file_path_);
    EXPECT_EQ(file.second, SafeFD::Error::kWrongPermissions);
    ASSERT_FALSE(file.first.is_valid());
  }
  ASSERT_EQ(chmod(file_path_.value().c_str(), SafeFD::kDefaultFilePermissions),
            0)
      << strerror(errno);

  EXPECT_EQ(chmod(sub_dir_path_.value().c_str(), 0777), 0) << strerror(errno);
  {
    SafeFD::SafeFDResult file = root_.MakeFile(file_path_);
    EXPECT_EQ(file.second, SafeFD::Error::kWrongPermissions);
    ASSERT_FALSE(file.first.is_valid());
  }
}

TEST_F(SafeFDTest, MakeDir_DoesNotExistSuccess) {
  {
    SafeFD::SafeFDResult dir = root_.MakeDir(sub_dir_path_);
    EXPECT_EQ(dir.second, SafeFD::Error::kNoError);
    ASSERT_TRUE(dir.first.is_valid());
  }

  ExpectPermissions(sub_dir_path_, SafeFD::kDefaultDirPermissions);
}

TEST_F(SafeFDTest, MakeFile_SingleComponentSuccess) {
  ASSERT_TRUE(SetupSubdir());

  SafeFD::Error err;
  SafeFD dir;
  std::tie(dir, err) = root_.OpenExistingDir(temp_dir_.GetPath());
  ASSERT_EQ(err, SafeFD::Error::kNoError);

  {
    SafeFD subdir;
    std::tie(subdir, err) = dir.MakeDir(base::FilePath(kSubdirName));
    EXPECT_EQ(err, SafeFD::Error::kNoError);
    ASSERT_TRUE(subdir.is_valid());
  }

  ExpectPermissions(sub_dir_path_, SafeFD::kDefaultDirPermissions);
}

TEST_F(SafeFDTest, MakeDir_ExistsSuccess) {
  ASSERT_TRUE(SetupSubdir());
  {
    SafeFD::SafeFDResult dir = root_.MakeDir(sub_dir_path_);
    EXPECT_EQ(dir.second, SafeFD::Error::kNoError);
    ASSERT_TRUE(dir.first.is_valid());
  }

  ExpectPermissions(sub_dir_path_, SafeFD::kDefaultDirPermissions);
}

TEST_F(SafeFDTest, MakeDir_WrongType) {
  ASSERT_TRUE(SetupSymlinks());
  SafeFD::SafeFDResult dir = root_.MakeDir(symlink_dir_path_);
  EXPECT_EQ(dir.second, SafeFD::Error::kWrongType);
  ASSERT_FALSE(dir.first.is_valid());
}

TEST_F(SafeFDTest, MakeDir_WrongGID) {
  ASSERT_TRUE(SetupSubdir());
  ASSERT_EQ(chown(sub_dir_path_.value().c_str(), getuid(), 0), 0)
      << strerror(errno);
  {
    SafeFD::SafeFDResult dir = root_.MakeDir(sub_dir_path_);
    EXPECT_EQ(dir.second, SafeFD::Error::kWrongGID);
    ASSERT_FALSE(dir.first.is_valid());
  }
}

TEST_F(SafeFDTest, MakeDir_WrongPermissions) {
  ASSERT_TRUE(SetupSubdir());
  ASSERT_EQ(chmod(sub_dir_path_.value().c_str(), 0777), 0) << strerror(errno);

  SafeFD::SafeFDResult dir = root_.MakeDir(sub_dir_path_);
  EXPECT_EQ(dir.second, SafeFD::Error::kWrongPermissions);
  ASSERT_FALSE(dir.first.is_valid());
}

TEST_F(SafeFDTest, Link_Success) {
  std::string data = GetRandomSuffix();
  ASSERT_TRUE(WriteFile(data));

  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  ASSERT_EQ(dir.second, SafeFD::Error::kNoError);

  SafeFD::SafeFDResult subdir = root_.OpenExistingDir(sub_dir_path_);
  ASSERT_EQ(subdir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(dir.first.Link(subdir.first, kFileName, kFileName),
            SafeFD::Error::kNoError);

  SafeFD::SafeFDResult new_file = dir.first.OpenExistingFile(
      base::FilePath(kFileName), O_RDONLY | O_CLOEXEC);
  EXPECT_EQ(new_file.second, SafeFD::Error::kNoError);
  std::pair<std::vector<char>, SafeFD::Error> contents =
      new_file.first.ReadContents();
  EXPECT_EQ(contents.second, SafeFD::Error::kNoError);
  EXPECT_EQ(data.size(), contents.first.size());
  EXPECT_EQ(memcmp(data.data(), contents.first.data(), data.size()), 0);
}

TEST_F(SafeFDTest, Link_NotInitialized) {
  std::string data = GetRandomSuffix();
  ASSERT_TRUE(WriteFile(data));

  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  ASSERT_EQ(dir.second, SafeFD::Error::kNoError);

  SafeFD::SafeFDResult subdir = root_.OpenExistingDir(sub_dir_path_);
  ASSERT_EQ(subdir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(SafeFD().Link(subdir.first, kFileName, kFileName),
            SafeFD::Error::kNotInitialized);

  EXPECT_EQ(dir.first.Link(SafeFD(), kFileName, kFileName),
            SafeFD::Error::kNotInitialized);
}

TEST_F(SafeFDTest, Link_BadArgument) {
  ASSERT_TRUE(WriteFile(""));

  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  ASSERT_EQ(dir.second, SafeFD::Error::kNoError);

  SafeFD::SafeFDResult subdir = root_.OpenExistingDir(sub_dir_path_);
  ASSERT_EQ(subdir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(dir.first.Link(subdir.first, "a/a", kFileName),
            SafeFD::Error::kBadArgument);
  EXPECT_EQ(dir.first.Link(subdir.first, ".", kFileName),
            SafeFD::Error::kBadArgument);
  EXPECT_EQ(dir.first.Link(subdir.first, "..", kFileName),
            SafeFD::Error::kBadArgument);
  EXPECT_EQ(dir.first.Link(subdir.first, kFileName, "a/a"),
            SafeFD::Error::kBadArgument);
  EXPECT_EQ(dir.first.Link(subdir.first, kFileName, "."),
            SafeFD::Error::kBadArgument);
  EXPECT_EQ(dir.first.Link(subdir.first, kFileName, ".."),
            SafeFD::Error::kBadArgument);
}

TEST_F(SafeFDTest, Link_IOError) {
  ASSERT_TRUE(SetupSubdir());

  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  ASSERT_EQ(dir.second, SafeFD::Error::kNoError);

  SafeFD::SafeFDResult subdir = root_.OpenExistingDir(sub_dir_path_);
  ASSERT_EQ(subdir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(dir.first.Link(subdir.first, kFileName, kFileName),
            SafeFD::Error::kIOError);
}

TEST_F(SafeFDTest, Unlink_Success) {
  ASSERT_TRUE(WriteFile(""));

  SafeFD::SafeFDResult subdir = root_.OpenExistingDir(sub_dir_path_);
  ASSERT_EQ(subdir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(subdir.first.Unlink(kFileName), SafeFD::Error::kNoError);
  EXPECT_FALSE(base::PathExists(file_path_));
}

TEST_F(SafeFDTest, Unlink_NotInitialized) {
  ASSERT_TRUE(WriteFile(""));

  EXPECT_EQ(SafeFD().Unlink(kFileName), SafeFD::Error::kNotInitialized);
}

TEST_F(SafeFDTest, Unlink_BadArgument) {
  ASSERT_TRUE(WriteFile(""));

  SafeFD::SafeFDResult subdir = root_.OpenExistingDir(sub_dir_path_);
  ASSERT_EQ(subdir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(subdir.first.Unlink("a/a"), SafeFD::Error::kBadArgument);
  EXPECT_EQ(subdir.first.Unlink("."), SafeFD::Error::kBadArgument);
  EXPECT_EQ(subdir.first.Unlink(".."), SafeFD::Error::kBadArgument);
}

TEST_F(SafeFDTest, Unlink_IOError_Nonexistent) {
  ASSERT_TRUE(SetupSubdir());

  SafeFD::SafeFDResult subdir = root_.OpenExistingDir(sub_dir_path_);
  ASSERT_EQ(subdir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(subdir.first.Unlink(kFileName), SafeFD::Error::kIOError);
}

TEST_F(SafeFDTest, Unlink_IOError_IsADir) {
  ASSERT_TRUE(SetupSubdir());

  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  ASSERT_EQ(dir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(dir.first.Unlink(kSubdirName), SafeFD::Error::kIOError);
}

TEST_F(SafeFDTest, Rmdir_Recursive_Success) {
  ASSERT_TRUE(WriteFile(""));

  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  ASSERT_EQ(dir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(dir.first.Rmdir(kSubdirName, true /*recursive*/),
            SafeFD::Error::kNoError);
  EXPECT_FALSE(base::PathExists(file_path_));
  EXPECT_FALSE(base::PathExists(sub_dir_path_));
}

TEST_F(SafeFDTest, Rmdir_Recursive_SuccessMaxRecursion) {
  SafeFD::Error err;
  SafeFD dir;

  // Create directory with the maximum depth.
  std::tie(dir, err) = root_.OpenExistingDir(temp_dir_.GetPath());
  EXPECT_EQ(err, SafeFD::Error::kNoError);
  ASSERT_TRUE(dir.is_valid());
  for (size_t x = 0; x < SafeFD::kDefaultMaxPathDepth; ++x) {
    std::tie(dir, err) = dir.MakeDir(base::FilePath(kSubdirName));
    EXPECT_EQ(err, SafeFD::Error::kNoError);
    ASSERT_TRUE(dir.is_valid());
  }

  // Check if recursive Rmdir succeeds (i.e. there isn't a stack overflow).
  std::tie(dir, err) = root_.OpenExistingDir(temp_dir_.GetPath());
  EXPECT_EQ(err, SafeFD::Error::kNoError);

  EXPECT_EQ(dir.Rmdir(kSubdirName, true /*recursive*/),
            SafeFD::Error::kNoError);
  EXPECT_FALSE(base::PathExists(file_path_));
  EXPECT_FALSE(base::PathExists(sub_dir_path_));
}

TEST_F(SafeFDTest, Rmdir_NotInitialized) {
  ASSERT_TRUE(WriteFile(""));

  EXPECT_EQ(SafeFD().Rmdir(kSubdirName, true /*recursive*/),
            SafeFD::Error::kNotInitialized);
}

TEST_F(SafeFDTest, Rmdir_BadArgument) {
  ASSERT_TRUE(WriteFile(""));

  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  EXPECT_EQ(dir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(dir.first.Rmdir("a/a"), SafeFD::Error::kBadArgument);
  EXPECT_EQ(dir.first.Rmdir("."), SafeFD::Error::kBadArgument);
  EXPECT_EQ(dir.first.Rmdir(".."), SafeFD::Error::kBadArgument);
}

TEST_F(SafeFDTest, Rmdir_ExceededMaximum) {
  ASSERT_TRUE(SetupSubdir());
  ASSERT_TRUE(base::CreateDirectory(sub_dir_path_.Append(kSubdirName)));

  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  ASSERT_EQ(dir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(dir.first.Rmdir(kSubdirName, true /*recursive*/, 1),
            SafeFD::Error::kExceededMaximum);
}

TEST_F(SafeFDTest, Rmdir_IOError) {
  SafeFD::SafeFDResult dir = root_.OpenExistingDir(temp_dir_.GetPath());
  ASSERT_EQ(dir.second, SafeFD::Error::kNoError);

  // Dir doesn't exist.
  EXPECT_EQ(dir.first.Rmdir(kSubdirName), SafeFD::Error::kIOError);

  // Dir not empty.
  ASSERT_TRUE(WriteFile(""));
  EXPECT_EQ(dir.first.Rmdir(kSubdirName), SafeFD::Error::kIOError);
}

TEST_F(SafeFDTest, Rmdir_WrongType) {
  ASSERT_TRUE(WriteFile(""));

  SafeFD::SafeFDResult subdir = root_.OpenExistingDir(sub_dir_path_);
  ASSERT_EQ(subdir.second, SafeFD::Error::kNoError);

  EXPECT_EQ(subdir.first.Rmdir(kFileName), SafeFD::Error::kWrongType);
}

TEST_F(SafeFDTest, Rmdir_Recursive_KeepGoing) {
  ASSERT_TRUE(SetupSubdir());

  ASSERT_TRUE(base::CreateDirectory(sub_dir_path_.Append(kSubdirName)));

  // Give us something to iterate over.
  constexpr int kNumSentinel = 25;
  for (int i = 0; i < kNumSentinel; i++) {
    SafeFD::SafeFDResult file =
        root_.MakeFile(sub_dir_path_.Append(GetRandomSuffix()));
    EXPECT_EQ(file.second, SafeFD::Error::kNoError);
    ASSERT_TRUE(file.first.is_valid());
  }

  // Recursively delete with a max level that is too small. Capture errno.
  SafeFD::Error result = root_.Rmdir(kSubdirName, true /*recursive*/,
                                     1 /*max_depth*/, true /*keep_going*/);
  int rmdir_errno = errno;

  EXPECT_EQ(result, SafeFD::Error::kExceededMaximum);

  // If we keep going, the last operation will be the post-order unlink of
  // the top-level directory. This has to fail with ENOTEMPTY since we did
  // not delete the too-deep sub-directories. This particular behavior
  // should not be part of the API contract and this can be relaxed if the
  // implementation is changed.
  EXPECT_EQ(rmdir_errno, ENOTEMPTY);

  // The deep directory must still exist.
  ASSERT_TRUE(
      base::DeleteFile(sub_dir_path_.Append(kSubdirName), false /*recursive*/));

  // We cannot control the iteration order so even if we incorrectly
  // stopped early the directory might still be empty if the deep
  // directories were last in the iteration order. But a non-empty
  // directory is always incorrect.
  ASSERT_TRUE(base::IsDirectoryEmpty(sub_dir_path_));
}

TEST_F(SafeFDTest, Rmdir_Recursive_StopOnError) {
  ASSERT_TRUE(SetupSubdir());

  ASSERT_TRUE(base::CreateDirectory(sub_dir_path_.Append(kSubdirName)));

  // Give us something to iterate over.
  constexpr int kNumSentinel = 25;
  for (int i = 0; i < kNumSentinel; i++) {
    SafeFD::SafeFDResult file =
        root_.MakeFile(sub_dir_path_.Append(GetRandomSuffix()));
    EXPECT_EQ(file.second, SafeFD::Error::kNoError);
    ASSERT_TRUE(file.first.is_valid());
  }

  // Recursively delete with a max level that is too small. Capture errno.
  SafeFD::Error result = root_.Rmdir(kSubdirName, true /*recursive*/,
                                     1 /*max_depth*/, false /*keep_going*/);
  int rmdir_errno = errno;

  EXPECT_EQ(result, SafeFD::Error::kExceededMaximum);

  // If we stop on encountering a too-deep directory, we never actually
  // make any libc calls that encounter errors. This particular behavior
  // should not be part of the API contract and this can be relaxed if the
  // implementation is changed.
  EXPECT_EQ(rmdir_errno, 0);

  // The deep directory must still exist.
  ASSERT_TRUE(
      base::DeleteFile(sub_dir_path_.Append(kSubdirName), false /*recursive*/));
}

}  // namespace brillo