// Copyright 2015 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/streams/file_stream.h>

#include <limits>
#include <numeric>
#include <string>
#include <sys/stat.h>
#include <vector>

#include <base/files/file_util.h>
#include <base/files/scoped_temp_dir.h>
#include <base/message_loop/message_loop.h>
#include <base/rand_util.h>
#include <base/run_loop.h>
#include <brillo/bind_lambda.h>
#include <brillo/errors/error_codes.h>
#include <brillo/message_loops/base_message_loop.h>
#include <brillo/message_loops/message_loop_utils.h>
#include <brillo/streams/stream_errors.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

using testing::InSequence;
using testing::Return;
using testing::ReturnArg;
using testing::SaveArg;
using testing::SetErrnoAndReturn;
using testing::_;

namespace brillo {

namespace {

// gmock action that would return a blocking situation from a read() or write().
ACTION(ReturnWouldBlock) {
  errno = EWOULDBLOCK;
  return -1;
}

// Helper function to read one byte from the stream.
inline int ReadByte(Stream* stream) {
  uint8_t byte = 0;
  return stream->ReadAllBlocking(&byte, sizeof(byte), nullptr) ? byte : -1;
}

// Helper function to write one byte from the stream.
inline bool WriteByte(Stream* stream, uint8_t byte) {
  return stream->WriteAllBlocking(&byte, sizeof(byte), nullptr);
}

// Helper function to test file stream workflow on newly created file.
void TestCreateFile(Stream* stream) {
  ASSERT_TRUE(stream->IsOpen());

  // Set up a sample data buffer.
  std::vector<uint8_t> in_buffer(256);
  std::iota(in_buffer.begin(), in_buffer.end(), 0);

  // Initial assumptions about empty file stream.
  EXPECT_TRUE(stream->CanRead());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_TRUE(stream->CanSeek());
  EXPECT_TRUE(stream->CanGetSize());
  EXPECT_EQ(0, stream->GetPosition());
  EXPECT_EQ(0, stream->GetSize());

  // Write sample data.
  EXPECT_TRUE(stream->WriteAllBlocking(in_buffer.data(), in_buffer.size(),
                                       nullptr));
  EXPECT_EQ(in_buffer.size(), stream->GetPosition());
  EXPECT_EQ(in_buffer.size(), stream->GetSize());

  // Rewind the stream to the beginning.
  uint64_t pos = 0;
  EXPECT_TRUE(stream->Seek(0, Stream::Whence::FROM_BEGIN, &pos, nullptr));
  EXPECT_EQ(0, pos);
  EXPECT_EQ(0, stream->GetPosition());
  EXPECT_EQ(in_buffer.size(), stream->GetSize());

  // Read the file contents back.
  std::vector<uint8_t> out_buffer(256);
  EXPECT_TRUE(stream->ReadAllBlocking(out_buffer.data(), out_buffer.size(),
                                      nullptr));
  EXPECT_EQ(out_buffer.size(), stream->GetPosition());
  EXPECT_EQ(out_buffer.size(), stream->GetSize());

  // Make sure the data read matches those written.
  EXPECT_EQ(in_buffer, out_buffer);

  // Random read/write
  EXPECT_TRUE(stream->Seek(10, Stream::Whence::FROM_BEGIN, &pos, nullptr));
  EXPECT_EQ(10, pos);

  // Since our data buffer contained values from 0 to 255, the byte at position
  // 10 will contain the value of 10.
  EXPECT_EQ(10, ReadByte(stream));
  EXPECT_EQ(11, ReadByte(stream));
  EXPECT_EQ(12, ReadByte(stream));
  EXPECT_TRUE(stream->Seek(7, Stream::Whence::FROM_CURRENT, nullptr, nullptr));
  EXPECT_EQ(20, ReadByte(stream));

  EXPECT_EQ(21, stream->GetPosition());
  EXPECT_TRUE(stream->Seek(-2, Stream::Whence::FROM_CURRENT, &pos, nullptr));
  EXPECT_EQ(19, pos);
  EXPECT_TRUE(WriteByte(stream, 100));
  EXPECT_EQ(20, ReadByte(stream));
  EXPECT_TRUE(stream->Seek(-2, Stream::Whence::FROM_CURRENT, nullptr, nullptr));
  EXPECT_EQ(100, ReadByte(stream));
  EXPECT_EQ(20, ReadByte(stream));
  EXPECT_TRUE(stream->Seek(-1, Stream::Whence::FROM_END, &pos, nullptr));
  EXPECT_EQ(255, pos);
  EXPECT_EQ(255, ReadByte(stream));
  EXPECT_EQ(-1, ReadByte(stream));
}

}  // anonymous namespace

// A mock file descriptor wrapper to test low-level file API used by FileStream.
class MockFileDescriptor : public FileStream::FileDescriptorInterface {
 public:
  MOCK_CONST_METHOD0(IsOpen, bool());
  MOCK_METHOD2(Read, ssize_t(void*, size_t));
  MOCK_METHOD2(Write, ssize_t(const void*, size_t));
  MOCK_METHOD2(Seek, off64_t(off64_t, int));
  MOCK_CONST_METHOD0(GetFileMode, mode_t());
  MOCK_CONST_METHOD0(GetSize, uint64_t());
  MOCK_CONST_METHOD1(Truncate, int(off64_t));
  MOCK_METHOD0(Flush, int());
  MOCK_METHOD0(Close, int());
  MOCK_METHOD3(WaitForData,
               bool(Stream::AccessMode, const DataCallback&, ErrorPtr*));
  MOCK_METHOD3(WaitForDataBlocking,
               int(Stream::AccessMode, base::TimeDelta, Stream::AccessMode*));
  MOCK_METHOD0(CancelPendingAsyncOperations, void());
};

class FileStreamTest : public testing::Test {
 public:
  void SetUp() override {
    CreateStream(S_IFREG, Stream::AccessMode::READ_WRITE);
  }

  MockFileDescriptor& fd_mock() {
    return *static_cast<MockFileDescriptor*>(stream_->fd_interface_.get());
  }

  void CreateStream(mode_t file_mode, Stream::AccessMode access_mode) {
    std::unique_ptr<MockFileDescriptor> fd{new MockFileDescriptor{}};
    EXPECT_CALL(*fd, GetFileMode()).WillOnce(Return(file_mode));
    stream_.reset(new FileStream(std::move(fd), access_mode));
    EXPECT_CALL(fd_mock(), IsOpen()).WillRepeatedly(Return(true));
  }

  void ExpectStreamClosed(const ErrorPtr& error) const {
    EXPECT_EQ(errors::stream::kDomain, error->GetDomain());
    EXPECT_EQ(errors::stream::kStreamClosed, error->GetCode());
    EXPECT_EQ("Stream is closed", error->GetMessage());
  }

  void ExpectStreamOffsetTooLarge(const ErrorPtr& error) const {
    EXPECT_EQ(errors::stream::kDomain, error->GetDomain());
    EXPECT_EQ(errors::stream::kInvalidParameter, error->GetCode());
    EXPECT_EQ("The stream offset value is out of range", error->GetMessage());
  }

  inline static char* IntToPtr(int addr) {
    return reinterpret_cast<char*>(addr);
  }

  inline static const char* IntToConstPtr(int addr) {
    return reinterpret_cast<const char*>(addr);
  }

  bool CallWaitForData(Stream::AccessMode mode, ErrorPtr* error) {
    return stream_->WaitForData(mode, {}, error);
  }

  std::unique_ptr<FileStream> stream_;

  const uint64_t kMaxSize = std::numeric_limits<int64_t>::max();
  const uint64_t kTooLargeSize = std::numeric_limits<uint64_t>::max();

  // Dummy buffer pointer values to make sure that input pointer values
  // are delegated to the file interface without a change.
  char* const test_read_buffer_ = IntToPtr(12345);
  const char* const test_write_buffer_ = IntToConstPtr(67890);
};

TEST_F(FileStreamTest, IsOpen) {
  EXPECT_TRUE(stream_->IsOpen());
  EXPECT_CALL(fd_mock(), IsOpen()).WillOnce(Return(false));
  EXPECT_FALSE(stream_->IsOpen());
}

TEST_F(FileStreamTest, CanRead) {
  CreateStream(S_IFREG, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanRead());
  EXPECT_CALL(fd_mock(), IsOpen()).WillRepeatedly(Return(false));
  EXPECT_FALSE(stream_->CanRead());
  CreateStream(S_IFREG, Stream::AccessMode::READ);
  EXPECT_TRUE(stream_->CanRead());
  CreateStream(S_IFREG, Stream::AccessMode::WRITE);
  EXPECT_FALSE(stream_->CanRead());
}

TEST_F(FileStreamTest, CanWrite) {
  CreateStream(S_IFREG, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanWrite());
  EXPECT_CALL(fd_mock(), IsOpen()).WillRepeatedly(Return(false));
  EXPECT_FALSE(stream_->CanWrite());
  CreateStream(S_IFREG, Stream::AccessMode::READ);
  EXPECT_FALSE(stream_->CanWrite());
  CreateStream(S_IFREG, Stream::AccessMode::WRITE);
  EXPECT_TRUE(stream_->CanWrite());
}

TEST_F(FileStreamTest, CanSeek) {
  CreateStream(S_IFBLK, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanSeek());
  CreateStream(S_IFDIR, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanSeek());
  CreateStream(S_IFREG, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanSeek());
  CreateStream(S_IFLNK, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanSeek());
  CreateStream(S_IFCHR, Stream::AccessMode::READ_WRITE);
  EXPECT_FALSE(stream_->CanSeek());
  CreateStream(S_IFSOCK, Stream::AccessMode::READ_WRITE);
  EXPECT_FALSE(stream_->CanSeek());
  CreateStream(S_IFIFO, Stream::AccessMode::READ_WRITE);
  EXPECT_FALSE(stream_->CanSeek());

  CreateStream(S_IFREG, Stream::AccessMode::READ);
  EXPECT_TRUE(stream_->CanSeek());
  CreateStream(S_IFREG, Stream::AccessMode::WRITE);
  EXPECT_TRUE(stream_->CanSeek());
}

TEST_F(FileStreamTest, CanGetSize) {
  CreateStream(S_IFBLK, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanGetSize());
  CreateStream(S_IFDIR, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanGetSize());
  CreateStream(S_IFREG, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanGetSize());
  CreateStream(S_IFLNK, Stream::AccessMode::READ_WRITE);
  EXPECT_TRUE(stream_->CanGetSize());
  CreateStream(S_IFCHR, Stream::AccessMode::READ_WRITE);
  EXPECT_FALSE(stream_->CanGetSize());
  CreateStream(S_IFSOCK, Stream::AccessMode::READ_WRITE);
  EXPECT_FALSE(stream_->CanGetSize());
  CreateStream(S_IFIFO, Stream::AccessMode::READ_WRITE);
  EXPECT_FALSE(stream_->CanGetSize());

  CreateStream(S_IFREG, Stream::AccessMode::READ);
  EXPECT_TRUE(stream_->CanGetSize());
  CreateStream(S_IFREG, Stream::AccessMode::WRITE);
  EXPECT_TRUE(stream_->CanGetSize());
}

TEST_F(FileStreamTest, GetSize) {
  EXPECT_CALL(fd_mock(), GetSize()).WillRepeatedly(Return(12345));
  EXPECT_EQ(12345u, stream_->GetSize());
  EXPECT_CALL(fd_mock(), IsOpen()).WillOnce(Return(false));
  EXPECT_EQ(0u, stream_->GetSize());
}

TEST_F(FileStreamTest, SetSizeBlocking) {
  EXPECT_CALL(fd_mock(), Truncate(0)).WillOnce(Return(0));
  EXPECT_TRUE(stream_->SetSizeBlocking(0, nullptr));

  EXPECT_CALL(fd_mock(), Truncate(123)).WillOnce(Return(0));
  EXPECT_TRUE(stream_->SetSizeBlocking(123, nullptr));

  EXPECT_CALL(fd_mock(), Truncate(kMaxSize)).WillOnce(Return(0));
  EXPECT_TRUE(stream_->SetSizeBlocking(kMaxSize, nullptr));
}

TEST_F(FileStreamTest, SetSizeBlocking_Fail) {
  brillo::ErrorPtr error;

  EXPECT_CALL(fd_mock(), Truncate(1235)).WillOnce(SetErrnoAndReturn(EIO, -1));
  EXPECT_FALSE(stream_->SetSizeBlocking(1235, &error));
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("EIO", error->GetCode());

  error.reset();
  EXPECT_FALSE(stream_->SetSizeBlocking(kTooLargeSize, &error));
  ExpectStreamOffsetTooLarge(error);

  error.reset();
  EXPECT_CALL(fd_mock(), IsOpen()).WillOnce(Return(false));
  EXPECT_FALSE(stream_->SetSizeBlocking(1235, &error));
  ExpectStreamClosed(error);
}

TEST_F(FileStreamTest, GetRemainingSize) {
  EXPECT_CALL(fd_mock(), Seek(0, SEEK_CUR)).WillOnce(Return(234));
  EXPECT_CALL(fd_mock(), GetSize()).WillOnce(Return(1234));
  EXPECT_EQ(1000u, stream_->GetRemainingSize());

  EXPECT_CALL(fd_mock(), Seek(0, SEEK_CUR)).WillOnce(Return(1234));
  EXPECT_CALL(fd_mock(), GetSize()).WillOnce(Return(1000));
  EXPECT_EQ(0u, stream_->GetRemainingSize());
}

TEST_F(FileStreamTest, Seek_Set) {
  uint64_t pos = 0;

  EXPECT_CALL(fd_mock(), Seek(0, SEEK_SET)).WillOnce(Return(0));
  EXPECT_TRUE(stream_->Seek(0, Stream::Whence::FROM_BEGIN, &pos, nullptr));
  EXPECT_EQ(0u, pos);

  EXPECT_CALL(fd_mock(), Seek(123456, SEEK_SET)).WillOnce(Return(123456));
  EXPECT_TRUE(stream_->Seek(123456, Stream::Whence::FROM_BEGIN, &pos, nullptr));
  EXPECT_EQ(123456u, pos);

  EXPECT_CALL(fd_mock(), Seek(kMaxSize, SEEK_SET))
      .WillRepeatedly(Return(kMaxSize));
  EXPECT_TRUE(stream_->Seek(kMaxSize, Stream::Whence::FROM_BEGIN, &pos,
              nullptr));
  EXPECT_EQ(kMaxSize, pos);
  EXPECT_TRUE(stream_->Seek(kMaxSize, Stream::Whence::FROM_BEGIN, nullptr,
              nullptr));
}

TEST_F(FileStreamTest, Seek_Cur) {
  uint64_t pos = 0;

  EXPECT_CALL(fd_mock(), Seek(0, SEEK_CUR)).WillOnce(Return(100));
  EXPECT_TRUE(stream_->Seek(0, Stream::Whence::FROM_CURRENT, &pos, nullptr));
  EXPECT_EQ(100u, pos);

  EXPECT_CALL(fd_mock(), Seek(234, SEEK_CUR)).WillOnce(Return(1234));
  EXPECT_TRUE(stream_->Seek(234, Stream::Whence::FROM_CURRENT, &pos, nullptr));
  EXPECT_EQ(1234u, pos);

  EXPECT_CALL(fd_mock(), Seek(-100, SEEK_CUR)).WillOnce(Return(900));
  EXPECT_TRUE(stream_->Seek(-100, Stream::Whence::FROM_CURRENT, &pos, nullptr));
  EXPECT_EQ(900u, pos);
}

TEST_F(FileStreamTest, Seek_End) {
  uint64_t pos = 0;

  EXPECT_CALL(fd_mock(), Seek(0, SEEK_END)).WillOnce(Return(1000));
  EXPECT_TRUE(stream_->Seek(0, Stream::Whence::FROM_END, &pos, nullptr));
  EXPECT_EQ(1000u, pos);

  EXPECT_CALL(fd_mock(), Seek(234, SEEK_END)).WillOnce(Return(10234));
  EXPECT_TRUE(stream_->Seek(234, Stream::Whence::FROM_END, &pos, nullptr));
  EXPECT_EQ(10234u, pos);

  EXPECT_CALL(fd_mock(), Seek(-100, SEEK_END)).WillOnce(Return(9900));
  EXPECT_TRUE(stream_->Seek(-100, Stream::Whence::FROM_END, &pos, nullptr));
  EXPECT_EQ(9900u, pos);
}

TEST_F(FileStreamTest, Seek_Fail) {
  brillo::ErrorPtr error;
  EXPECT_CALL(fd_mock(), Seek(0, SEEK_SET))
      .WillOnce(SetErrnoAndReturn(EPIPE, -1));
  EXPECT_FALSE(stream_->Seek(0, Stream::Whence::FROM_BEGIN, nullptr, &error));
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("EPIPE", error->GetCode());
}

TEST_F(FileStreamTest, ReadAsync) {
  size_t read_size = 0;
  bool failed = false;
  auto success_callback = [&read_size](size_t size) { read_size = size; };
  auto error_callback = [&failed](const Error* /* error */) { failed = true; };
  FileStream::FileDescriptorInterface::DataCallback data_callback;

  EXPECT_CALL(fd_mock(), Read(test_read_buffer_, 100))
      .WillOnce(ReturnWouldBlock());
  EXPECT_CALL(fd_mock(), WaitForData(Stream::AccessMode::READ, _, _))
      .WillOnce(DoAll(SaveArg<1>(&data_callback), Return(true)));
  EXPECT_TRUE(stream_->ReadAsync(test_read_buffer_, 100,
                                 base::Bind(success_callback),
                                 base::Bind(error_callback),
                                 nullptr));
  EXPECT_EQ(0u, read_size);
  EXPECT_FALSE(failed);

  EXPECT_CALL(fd_mock(), Read(test_read_buffer_, 100)).WillOnce(Return(83));
  data_callback.Run(Stream::AccessMode::READ);
  EXPECT_EQ(83u, read_size);
  EXPECT_FALSE(failed);
}

TEST_F(FileStreamTest, ReadNonBlocking) {
  size_t size = 0;
  bool eos = false;
  EXPECT_CALL(fd_mock(), Read(test_read_buffer_, _))
      .WillRepeatedly(ReturnArg<1>());
  EXPECT_TRUE(stream_->ReadNonBlocking(test_read_buffer_, 100, &size, &eos,
                                       nullptr));
  EXPECT_EQ(100u, size);
  EXPECT_FALSE(eos);

  EXPECT_TRUE(stream_->ReadNonBlocking(test_read_buffer_, 0, &size, &eos,
                                       nullptr));
  EXPECT_EQ(0u, size);
  EXPECT_FALSE(eos);

  EXPECT_CALL(fd_mock(), Read(test_read_buffer_, _)).WillOnce(Return(0));
  EXPECT_TRUE(stream_->ReadNonBlocking(test_read_buffer_, 100, &size, &eos,
                                       nullptr));
  EXPECT_EQ(0u, size);
  EXPECT_TRUE(eos);

  EXPECT_CALL(fd_mock(), Read(test_read_buffer_, _))
      .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
  EXPECT_TRUE(stream_->ReadNonBlocking(test_read_buffer_, 100, &size, &eos,
                                       nullptr));
  EXPECT_EQ(0u, size);
  EXPECT_FALSE(eos);
}

TEST_F(FileStreamTest, ReadNonBlocking_Fail) {
  size_t size = 0;
  brillo::ErrorPtr error;
  EXPECT_CALL(fd_mock(), Read(test_read_buffer_, _))
      .WillOnce(SetErrnoAndReturn(EACCES, -1));
  EXPECT_FALSE(stream_->ReadNonBlocking(test_read_buffer_, 100, &size, nullptr,
                                        &error));
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("EACCES", error->GetCode());
}

TEST_F(FileStreamTest, ReadBlocking) {
  size_t size = 0;
  EXPECT_CALL(fd_mock(), Read(test_read_buffer_, 100)).WillOnce(Return(20));
  EXPECT_TRUE(stream_->ReadBlocking(test_read_buffer_, 100, &size, nullptr));
  EXPECT_EQ(20u, size);

  {
    InSequence seq;
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_, 80))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::READ, _, _))
        .WillOnce(Return(1));
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_, 80)).WillOnce(Return(45));
  }
  EXPECT_TRUE(stream_->ReadBlocking(test_read_buffer_, 80, &size, nullptr));
  EXPECT_EQ(45u, size);

  EXPECT_CALL(fd_mock(), Read(test_read_buffer_, 50)).WillOnce(Return(0));
  EXPECT_TRUE(stream_->ReadBlocking(test_read_buffer_, 50, &size, nullptr));
  EXPECT_EQ(0u, size);
}

TEST_F(FileStreamTest, ReadBlocking_Fail) {
  {
    InSequence seq;
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_, 80))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::READ, _, _))
        .WillOnce(SetErrnoAndReturn(EBADF, -1));
  }
  brillo::ErrorPtr error;
  size_t size = 0;
  EXPECT_FALSE(stream_->ReadBlocking(test_read_buffer_, 80, &size, &error));
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("EBADF", error->GetCode());
}

TEST_F(FileStreamTest, ReadAllBlocking) {
  {
    InSequence seq;
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_, 100)).WillOnce(Return(20));
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_ + 20, 80))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::READ, _, _))
        .WillOnce(Return(1));
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_ + 20, 80))
        .WillOnce(Return(45));
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_ + 65, 35))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::READ, _, _))
        .WillOnce(Return(1));
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_ + 65, 35))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::READ, _, _))
        .WillOnce(Return(1));
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_ + 65, 35))
        .WillOnce(Return(35));
  }
  EXPECT_TRUE(stream_->ReadAllBlocking(test_read_buffer_, 100, nullptr));
}

TEST_F(FileStreamTest, ReadAllBlocking_Fail) {
  {
    InSequence seq;
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_, 100)).WillOnce(Return(20));
    EXPECT_CALL(fd_mock(), Read(test_read_buffer_ + 20, 80))
        .WillOnce(Return(0));
  }
  brillo::ErrorPtr error;
  EXPECT_FALSE(stream_->ReadAllBlocking(test_read_buffer_, 100, &error));
  EXPECT_EQ(errors::stream::kDomain, error->GetDomain());
  EXPECT_EQ(errors::stream::kPartialData, error->GetCode());
  EXPECT_EQ("Reading past the end of stream", error->GetMessage());
}

TEST_F(FileStreamTest, WriteAsync) {
  size_t write_size = 0;
  bool failed = false;
  auto success_callback = [&write_size](size_t size) { write_size = size; };
  auto error_callback = [&failed](const Error* /* error */) { failed = true; };
  FileStream::FileDescriptorInterface::DataCallback data_callback;

  EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 100))
      .WillOnce(ReturnWouldBlock());
  EXPECT_CALL(fd_mock(), WaitForData(Stream::AccessMode::WRITE, _, _))
      .WillOnce(DoAll(SaveArg<1>(&data_callback), Return(true)));
  EXPECT_TRUE(stream_->WriteAsync(test_write_buffer_, 100,
                                  base::Bind(success_callback),
                                  base::Bind(error_callback),
                                  nullptr));
  EXPECT_EQ(0u, write_size);
  EXPECT_FALSE(failed);

  EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 100)).WillOnce(Return(87));
  data_callback.Run(Stream::AccessMode::WRITE);
  EXPECT_EQ(87u, write_size);
  EXPECT_FALSE(failed);
}

TEST_F(FileStreamTest, WriteNonBlocking) {
  size_t size = 0;
  EXPECT_CALL(fd_mock(), Write(test_write_buffer_, _))
      .WillRepeatedly(ReturnArg<1>());
  EXPECT_TRUE(stream_->WriteNonBlocking(test_write_buffer_, 100, &size,
                                        nullptr));
  EXPECT_EQ(100u, size);

  EXPECT_TRUE(stream_->WriteNonBlocking(test_write_buffer_, 0, &size, nullptr));
  EXPECT_EQ(0u, size);

  EXPECT_CALL(fd_mock(), Write(test_write_buffer_, _)).WillOnce(Return(0));
  EXPECT_TRUE(stream_->WriteNonBlocking(test_write_buffer_, 100, &size,
                                        nullptr));
  EXPECT_EQ(0u, size);

  EXPECT_CALL(fd_mock(), Write(test_write_buffer_, _))
      .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
  EXPECT_TRUE(stream_->WriteNonBlocking(test_write_buffer_, 100, &size,
                                        nullptr));
  EXPECT_EQ(0u, size);
}

TEST_F(FileStreamTest, WriteNonBlocking_Fail) {
  size_t size = 0;
  brillo::ErrorPtr error;
  EXPECT_CALL(fd_mock(), Write(test_write_buffer_, _))
      .WillOnce(SetErrnoAndReturn(EACCES, -1));
  EXPECT_FALSE(stream_->WriteNonBlocking(test_write_buffer_, 100, &size,
                                         &error));
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("EACCES", error->GetCode());
}

TEST_F(FileStreamTest, WriteBlocking) {
  size_t size = 0;
  EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 100)).WillOnce(Return(20));
  EXPECT_TRUE(stream_->WriteBlocking(test_write_buffer_, 100, &size, nullptr));
  EXPECT_EQ(20u, size);

  {
    InSequence seq;
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 80))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::WRITE, _, _))
        .WillOnce(Return(1));
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 80)).WillOnce(Return(45));
  }
  EXPECT_TRUE(stream_->WriteBlocking(test_write_buffer_, 80, &size, nullptr));
  EXPECT_EQ(45u, size);

  {
    InSequence seq;
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 50)).WillOnce(Return(0));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::WRITE, _, _))
        .WillOnce(Return(1));
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 50)).WillOnce(Return(1));
  }
  EXPECT_TRUE(stream_->WriteBlocking(test_write_buffer_, 50, &size, nullptr));
  EXPECT_EQ(1u, size);
}

TEST_F(FileStreamTest, WriteBlocking_Fail) {
  {
    InSequence seq;
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 80))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::WRITE, _, _))
        .WillOnce(SetErrnoAndReturn(EBADF, -1));
  }
  brillo::ErrorPtr error;
  size_t size = 0;
  EXPECT_FALSE(stream_->WriteBlocking(test_write_buffer_, 80, &size, &error));
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("EBADF", error->GetCode());
}

TEST_F(FileStreamTest, WriteAllBlocking) {
  {
    InSequence seq;
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 100)).WillOnce(Return(20));
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_ + 20, 80))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::WRITE, _, _))
        .WillOnce(Return(1));
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_ + 20, 80))
        .WillOnce(Return(45));
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_ + 65, 35))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::WRITE, _, _))
        .WillOnce(Return(1));
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_ + 65, 35))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::WRITE, _, _))
        .WillOnce(Return(1));
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_ + 65, 35))
        .WillOnce(Return(35));
  }
  EXPECT_TRUE(stream_->WriteAllBlocking(test_write_buffer_, 100, nullptr));
}

TEST_F(FileStreamTest, WriteAllBlocking_Fail) {
  {
    InSequence seq;
    EXPECT_CALL(fd_mock(), Write(test_write_buffer_, 80))
        .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
    EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::WRITE, _, _))
        .WillOnce(SetErrnoAndReturn(EBADF, -1));
  }
  brillo::ErrorPtr error;
  EXPECT_FALSE(stream_->WriteAllBlocking(test_write_buffer_, 80, &error));
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("EBADF", error->GetCode());
}

TEST_F(FileStreamTest, WaitForDataBlocking_Timeout) {
  EXPECT_CALL(fd_mock(), WaitForDataBlocking(Stream::AccessMode::WRITE, _, _))
      .WillOnce(Return(0));
  brillo::ErrorPtr error;
  EXPECT_FALSE(stream_->WaitForDataBlocking(Stream::AccessMode::WRITE, {},
                                            nullptr, &error));
  EXPECT_EQ(errors::stream::kDomain, error->GetDomain());
  EXPECT_EQ(errors::stream::kTimeout, error->GetCode());
}

TEST_F(FileStreamTest, FlushBlocking) {
  EXPECT_TRUE(stream_->FlushBlocking(nullptr));
}

TEST_F(FileStreamTest, CloseBlocking) {
  EXPECT_CALL(fd_mock(), Close()).WillOnce(Return(0));
  EXPECT_TRUE(stream_->CloseBlocking(nullptr));

  EXPECT_CALL(fd_mock(), IsOpen()).WillOnce(Return(false));
  EXPECT_TRUE(stream_->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, CloseBlocking_Fail) {
  brillo::ErrorPtr error;
  EXPECT_CALL(fd_mock(), Close()).WillOnce(SetErrnoAndReturn(EFBIG, -1));
  EXPECT_FALSE(stream_->CloseBlocking(&error));
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("EFBIG", error->GetCode());
}

TEST_F(FileStreamTest, WaitForData) {
  EXPECT_CALL(fd_mock(), WaitForData(Stream::AccessMode::READ, _, _))
      .WillOnce(Return(true));
  EXPECT_TRUE(CallWaitForData(Stream::AccessMode::READ, nullptr));

  EXPECT_CALL(fd_mock(), WaitForData(Stream::AccessMode::WRITE, _, _))
      .WillOnce(Return(true));
  EXPECT_TRUE(CallWaitForData(Stream::AccessMode::WRITE, nullptr));

  EXPECT_CALL(fd_mock(), WaitForData(Stream::AccessMode::READ_WRITE, _, _))
      .WillOnce(Return(true));
  EXPECT_TRUE(CallWaitForData(Stream::AccessMode::READ_WRITE, nullptr));

  EXPECT_CALL(fd_mock(), WaitForData(Stream::AccessMode::READ_WRITE, _, _))
      .WillOnce(Return(false));
  EXPECT_FALSE(CallWaitForData(Stream::AccessMode::READ_WRITE, nullptr));
}

TEST_F(FileStreamTest, CreateTemporary) {
  StreamPtr stream = FileStream::CreateTemporary(nullptr);
  ASSERT_NE(nullptr, stream.get());
  TestCreateFile(stream.get());
}

TEST_F(FileStreamTest, OpenRead) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});
  std::vector<char> buffer(1024 * 1024);
  base::RandBytes(buffer.data(), buffer.size());
  int file_size = buffer.size();  // Stupid base::WriteFile taking "int" size.
  ASSERT_EQ(file_size, base::WriteFile(path, buffer.data(), file_size));

  StreamPtr stream = FileStream::Open(path,
                                      Stream::AccessMode::READ,
                                      FileStream::Disposition::OPEN_EXISTING,
                                      nullptr);
  ASSERT_NE(nullptr, stream.get());
  ASSERT_TRUE(stream->IsOpen());
  EXPECT_TRUE(stream->CanRead());
  EXPECT_FALSE(stream->CanWrite());
  EXPECT_TRUE(stream->CanSeek());
  EXPECT_TRUE(stream->CanGetSize());
  EXPECT_EQ(0u, stream->GetPosition());
  EXPECT_EQ(buffer.size(), stream->GetSize());

  std::vector<char> buffer2(buffer.size());
  EXPECT_TRUE(stream->ReadAllBlocking(buffer2.data(), buffer2.size(), nullptr));
  EXPECT_EQ(buffer2, buffer);
  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, OpenWrite) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});
  std::vector<char> buffer(1024 * 1024);
  base::RandBytes(buffer.data(), buffer.size());

  StreamPtr stream = FileStream::Open(path,
                                      Stream::AccessMode::WRITE,
                                      FileStream::Disposition::CREATE_ALWAYS,
                                      nullptr);
  ASSERT_NE(nullptr, stream.get());
  ASSERT_TRUE(stream->IsOpen());
  EXPECT_FALSE(stream->CanRead());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_TRUE(stream->CanSeek());
  EXPECT_TRUE(stream->CanGetSize());
  EXPECT_EQ(0u, stream->GetPosition());
  EXPECT_EQ(0u, stream->GetSize());

  EXPECT_TRUE(stream->WriteAllBlocking(buffer.data(), buffer.size(), nullptr));
  EXPECT_TRUE(stream->CloseBlocking(nullptr));

  std::vector<char> buffer2(buffer.size());
  int file_size = buffer2.size();  // Stupid base::ReadFile taking "int" size.
  ASSERT_EQ(file_size, base::ReadFile(path, buffer2.data(), file_size));
  EXPECT_EQ(buffer2, buffer);
}

TEST_F(FileStreamTest, Open_OpenExisting) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});
  std::string data{"Lorem ipsum dolor sit amet ..."};
  int data_size = data.size();  // I hate ints for data size...
  ASSERT_EQ(data_size, base::WriteFile(path, data.data(), data_size));

  StreamPtr stream = FileStream::Open(path,
                                      Stream::AccessMode::READ_WRITE,
                                      FileStream::Disposition::OPEN_EXISTING,
                                      nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->CanRead());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_TRUE(stream->CanSeek());
  EXPECT_TRUE(stream->CanGetSize());
  EXPECT_EQ(0u, stream->GetPosition());
  EXPECT_EQ(data.size(), stream->GetSize());
  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, Open_OpenExisting_Fail) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});

  ErrorPtr error;
  StreamPtr stream = FileStream::Open(path,
                                      Stream::AccessMode::READ_WRITE,
                                      FileStream::Disposition::OPEN_EXISTING,
                                      &error);
  ASSERT_EQ(nullptr, stream.get());
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("ENOENT", error->GetCode());
}

TEST_F(FileStreamTest, Open_CreateAlways_New) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});

  StreamPtr stream = FileStream::Open(path,
                                      Stream::AccessMode::READ_WRITE,
                                      FileStream::Disposition::CREATE_ALWAYS,
                                      nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->CanRead());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_TRUE(stream->CanSeek());
  EXPECT_TRUE(stream->CanGetSize());
  EXPECT_EQ(0u, stream->GetPosition());
  EXPECT_EQ(0u, stream->GetSize());
  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, Open_CreateAlways_Existing) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});
  std::string data{"Lorem ipsum dolor sit amet ..."};
  int data_size = data.size();  // I hate ints for data size...
  ASSERT_EQ(data_size, base::WriteFile(path, data.data(), data_size));

  StreamPtr stream = FileStream::Open(path,
                                      Stream::AccessMode::READ_WRITE,
                                      FileStream::Disposition::CREATE_ALWAYS,
                                      nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->CanRead());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_TRUE(stream->CanSeek());
  EXPECT_TRUE(stream->CanGetSize());
  EXPECT_EQ(0u, stream->GetPosition());
  EXPECT_EQ(0u, stream->GetSize());
  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, Open_CreateNewOnly_New) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});

  StreamPtr stream = FileStream::Open(path,
                                      Stream::AccessMode::READ_WRITE,
                                      FileStream::Disposition::CREATE_NEW_ONLY,
                                      nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->CanRead());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_TRUE(stream->CanSeek());
  EXPECT_TRUE(stream->CanGetSize());
  EXPECT_EQ(0u, stream->GetPosition());
  EXPECT_EQ(0u, stream->GetSize());
  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, Open_CreateNewOnly_Existing) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});
  std::string data{"Lorem ipsum dolor sit amet ..."};
  int data_size = data.size();  // I hate ints for data size...
  ASSERT_EQ(data_size, base::WriteFile(path, data.data(), data_size));

  ErrorPtr error;
  StreamPtr stream = FileStream::Open(path,
                                      Stream::AccessMode::READ_WRITE,
                                      FileStream::Disposition::CREATE_NEW_ONLY,
                                      &error);
  ASSERT_EQ(nullptr, stream.get());
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("EEXIST", error->GetCode());
}

TEST_F(FileStreamTest, Open_TruncateExisting_New) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});

  ErrorPtr error;
  StreamPtr stream = FileStream::Open(
      path,
      Stream::AccessMode::READ_WRITE,
      FileStream::Disposition::TRUNCATE_EXISTING,
      &error);
  ASSERT_EQ(nullptr, stream.get());
  EXPECT_EQ(errors::system::kDomain, error->GetDomain());
  EXPECT_EQ("ENOENT", error->GetCode());
}

TEST_F(FileStreamTest, Open_TruncateExisting_Existing) {
  base::ScopedTempDir temp_dir;
  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  base::FilePath path = temp_dir.path().Append(base::FilePath{"test.dat"});
  std::string data{"Lorem ipsum dolor sit amet ..."};
  int data_size = data.size();  // I hate ints for data size...
  ASSERT_EQ(data_size, base::WriteFile(path, data.data(), data_size));

  StreamPtr stream = FileStream::Open(
      path,
      Stream::AccessMode::READ_WRITE,
      FileStream::Disposition::TRUNCATE_EXISTING,
      nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->CanRead());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_TRUE(stream->CanSeek());
  EXPECT_TRUE(stream->CanGetSize());
  EXPECT_EQ(0u, stream->GetPosition());
  EXPECT_EQ(0u, stream->GetSize());
  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, FromFileDescriptor_StdIn) {
  StreamPtr stream =
      FileStream::FromFileDescriptor(STDIN_FILENO, false, nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->IsOpen());
  EXPECT_TRUE(stream->CanRead());
  EXPECT_FALSE(stream->CanSeek());
  EXPECT_FALSE(stream->CanGetSize());
}

TEST_F(FileStreamTest, FromFileDescriptor_StdOut) {
  StreamPtr stream =
      FileStream::FromFileDescriptor(STDOUT_FILENO, false, nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->IsOpen());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_FALSE(stream->CanSeek());
  EXPECT_FALSE(stream->CanGetSize());
}

TEST_F(FileStreamTest, FromFileDescriptor_StdErr) {
  StreamPtr stream =
      FileStream::FromFileDescriptor(STDERR_FILENO, false, nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->IsOpen());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_FALSE(stream->CanSeek());
  EXPECT_FALSE(stream->CanGetSize());
}

TEST_F(FileStreamTest, FromFileDescriptor_ReadNonBlocking) {
  int fds[2] = {-1, -1};
  ASSERT_EQ(0, pipe(fds));

  StreamPtr stream = FileStream::FromFileDescriptor(fds[0], true, nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->IsOpen());
  EXPECT_TRUE(stream->CanRead());
  EXPECT_FALSE(stream->CanWrite());
  EXPECT_FALSE(stream->CanSeek());
  EXPECT_FALSE(stream->CanGetSize());

  char buf[10];
  size_t read = 0;
  bool eos = true;
  EXPECT_TRUE(stream->ReadNonBlocking(buf, sizeof(buf), &read, &eos, nullptr));
  EXPECT_EQ(0, read);
  EXPECT_FALSE(eos);

  std::string data{"foo_bar"};
  EXPECT_TRUE(base::WriteFileDescriptor(fds[1], data.data(), data.size()));
  EXPECT_TRUE(stream->ReadNonBlocking(buf, sizeof(buf), &read, &eos, nullptr));
  EXPECT_EQ(data.size(), read);
  EXPECT_FALSE(eos);
  EXPECT_EQ(data, (std::string{buf, read}));

  EXPECT_TRUE(stream->ReadNonBlocking(buf, sizeof(buf), &read, &eos, nullptr));
  EXPECT_EQ(0, read);
  EXPECT_FALSE(eos);

  close(fds[1]);

  EXPECT_TRUE(stream->ReadNonBlocking(buf, sizeof(buf), &read, &eos, nullptr));
  EXPECT_EQ(0, read);
  EXPECT_TRUE(eos);

  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, FromFileDescriptor_WriteNonBlocking) {
  int fds[2] = {-1, -1};
  ASSERT_EQ(0, pipe(fds));

  StreamPtr stream = FileStream::FromFileDescriptor(fds[1], true, nullptr);
  ASSERT_NE(nullptr, stream.get());
  EXPECT_TRUE(stream->IsOpen());
  EXPECT_FALSE(stream->CanRead());
  EXPECT_TRUE(stream->CanWrite());
  EXPECT_FALSE(stream->CanSeek());
  EXPECT_FALSE(stream->CanGetSize());

  // Pipe buffer is generally 64K, so 128K should be more than enough.
  std::vector<char> buffer(128 * 1024);
  base::RandBytes(buffer.data(), buffer.size());
  size_t written = 0;
  size_t total_size = 0;

  // Fill the output buffer of the pipe until we can no longer write any data
  // to it.
  do {
    ASSERT_TRUE(stream->WriteNonBlocking(buffer.data(), buffer.size(), &written,
                                         nullptr));
    total_size += written;
  } while (written == buffer.size());

  EXPECT_TRUE(stream->WriteNonBlocking(buffer.data(), buffer.size(), &written,
                                       nullptr));
  EXPECT_EQ(0, written);

  std::vector<char> out_buffer(total_size);
  EXPECT_TRUE(base::ReadFromFD(fds[0], out_buffer.data(), out_buffer.size()));

  EXPECT_TRUE(stream->WriteNonBlocking(buffer.data(), buffer.size(), &written,
                                       nullptr));
  EXPECT_GT(written, 0);
  out_buffer.resize(written);
  EXPECT_TRUE(base::ReadFromFD(fds[0], out_buffer.data(), out_buffer.size()));
  EXPECT_TRUE(std::equal(out_buffer.begin(), out_buffer.end(), buffer.begin()));

  close(fds[0]);
  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, FromFileDescriptor_ReadAsync) {
  int fds[2] = {-1, -1};
  bool succeeded = false;
  bool failed = false;
  char buffer[100];
  base::MessageLoopForIO base_loop;
  BaseMessageLoop brillo_loop{&base_loop};
  brillo_loop.SetAsCurrent();

  auto success_callback = [&succeeded, &buffer](size_t size) {
    std::string data{buffer, buffer + size};
    ASSERT_EQ("abracadabra", data);
    succeeded = true;
  };

  auto error_callback = [&failed](const Error* /* error */) {
    failed = true;
  };

  auto write_data_callback = [](int write_fd) {
    std::string data{"abracadabra"};
    EXPECT_TRUE(base::WriteFileDescriptor(write_fd, data.data(), data.size()));
  };

  ASSERT_EQ(0, pipe(fds));

  StreamPtr stream = FileStream::FromFileDescriptor(fds[0], true, nullptr);

  // Write to the pipe with a bit of delay.
  brillo_loop.PostDelayedTask(
      FROM_HERE,
      base::Bind(write_data_callback, fds[1]),
      base::TimeDelta::FromMilliseconds(10));

  EXPECT_TRUE(stream->ReadAsync(buffer, 100, base::Bind(success_callback),
                                base::Bind(error_callback), nullptr));

  auto end_condition = [&failed, &succeeded] { return failed || succeeded; };
  MessageLoopRunUntil(&brillo_loop,
                      base::TimeDelta::FromSeconds(1),
                      base::Bind(end_condition));

  EXPECT_TRUE(succeeded);
  EXPECT_FALSE(failed);

  close(fds[1]);
  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

TEST_F(FileStreamTest, FromFileDescriptor_WriteAsync) {
  int fds[2] = {-1, -1};
  bool succeeded = false;
  bool failed = false;
  const std::string data{"abracadabra"};
  base::MessageLoopForIO base_loop;
  BaseMessageLoop brillo_loop{&base_loop};
  brillo_loop.SetAsCurrent();

  ASSERT_EQ(0, pipe(fds));

  auto success_callback = [&succeeded, &data](int read_fd, size_t /* size */) {
    char buffer[100];
    EXPECT_TRUE(base::ReadFromFD(read_fd, buffer, data.size()));
    EXPECT_EQ(data, (std::string{buffer, buffer + data.size()}));
    succeeded = true;
  };

  auto error_callback = [&failed](const Error* /* error */) {
    failed = true;
  };

  StreamPtr stream = FileStream::FromFileDescriptor(fds[1], true, nullptr);

  EXPECT_TRUE(stream->WriteAsync(data.data(), data.size(),
                                 base::Bind(success_callback, fds[0]),
                                 base::Bind(error_callback), nullptr));

  auto end_condition = [&failed, &succeeded] { return failed || succeeded; };
  MessageLoopRunUntil(&brillo_loop,
                      base::TimeDelta::FromSeconds(1),
                      base::Bind(end_condition));

  EXPECT_TRUE(succeeded);
  EXPECT_FALSE(failed);

  close(fds[0]);
  EXPECT_TRUE(stream->CloseBlocking(nullptr));
}

}  // namespace brillo