rtc_base/file_rotating_stream_unittest.cc - src.git - Git at Google

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */

 #include <string.h>
 #include <cstdint>
 #include <memory>

 #include "rtc_base/arraysize.h"
 #include "rtc_base/file_rotating_stream.h"
 #include "test/gtest.h"
 #include "test/testsupport/file_utils.h"

 namespace rtc {

 namespace {

 void CleanupLogDirectory(const FileRotatingStream& stream) {
   for (size_t i = 0; i < stream.GetNumFiles(); ++i) {
     // Ignore return value, not all files are expected to exist.
     webrtc::test::RemoveFile(stream.GetFilePath(i));
   }
 }

 }  // namespace

 #if defined(WEBRTC_ANDROID)
 // Fails on Android: https://bugs.chromium.org/p/webrtc/issues/detail?id=4364.
 #define MAYBE_FileRotatingStreamTest DISABLED_FileRotatingStreamTest
 #else
 #define MAYBE_FileRotatingStreamTest FileRotatingStreamTest
 #endif

 class MAYBE_FileRotatingStreamTest : public ::testing::Test {
  protected:
   static const char* kFilePrefix;
   static const size_t kMaxFileSize;

   void Init(const std::string& dir_name,
             const std::string& file_prefix,
             size_t max_file_size,
             size_t num_log_files,
             bool ensure_trailing_delimiter = true) {
     dir_path_ = webrtc::test::OutputPath();

     // Append per-test output path in order to run within gtest parallel.
     dir_path_.append(dir_name);
     if (ensure_trailing_delimiter) {
       dir_path_.append(webrtc::test::kPathDelimiter);
     }
     ASSERT_TRUE(webrtc::test::CreateDir(dir_path_));
     stream_.reset(new FileRotatingStream(dir_path_, file_prefix, max_file_size,
                                          num_log_files));
   }

   void TearDown() override {
     // On windows, open files can't be removed.
     stream_->Close();
     CleanupLogDirectory(*stream_);
     EXPECT_TRUE(webrtc::test::RemoveDir(dir_path_));

     stream_.reset();
   }

   // Writes the data to the stream and flushes it.
   void WriteAndFlush(const void* data, const size_t data_len) {
     EXPECT_EQ(SR_SUCCESS, stream_->WriteAll(data, data_len, nullptr, nullptr));
     EXPECT_TRUE(stream_->Flush());
   }

   // Checks that the stream reads in the expected contents and then returns an
   // end of stream result.
   void VerifyStreamRead(const char* expected_contents,
                         const size_t expected_length,
                         const std::string& dir_path,
                         const char* file_prefix) {
     FileRotatingStreamReader reader(dir_path, file_prefix);
     EXPECT_EQ(reader.GetSize(), expected_length);
     std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
     memset(buffer.get(), 0, expected_length);
     EXPECT_EQ(expected_length, reader.ReadAll(buffer.get(), expected_length));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
   }

   void VerifyFileContents(const char* expected_contents,
                           const size_t expected_length,
                           const std::string& file_path) {
     std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length + 1]);
     webrtc::FileWrapper f = webrtc::FileWrapper::OpenReadOnly(file_path);
     ASSERT_TRUE(f.is_open());
     size_t size_read = f.Read(buffer.get(), expected_length + 1);
     EXPECT_EQ(size_read, expected_length);
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(),
                         std::min(expected_length, size_read)));
   }

   std::unique_ptr<FileRotatingStream> stream_;
   std::string dir_path_;
 };

 const char* MAYBE_FileRotatingStreamTest::kFilePrefix =
     "FileRotatingStreamTest";
 const size_t MAYBE_FileRotatingStreamTest::kMaxFileSize = 2;

 // Tests that stream state is correct before and after Open / Close.
 TEST_F(MAYBE_FileRotatingStreamTest, State) {
   Init("FileRotatingStreamTestState", kFilePrefix, kMaxFileSize, 3);

   EXPECT_EQ(SS_CLOSED, stream_->GetState());
   ASSERT_TRUE(stream_->Open());
   EXPECT_EQ(SS_OPEN, stream_->GetState());
   stream_->Close();
   EXPECT_EQ(SS_CLOSED, stream_->GetState());
 }

 // Tests that nothing is written to file when data of length zero is written.
 TEST_F(MAYBE_FileRotatingStreamTest, EmptyWrite) {
   Init("FileRotatingStreamTestEmptyWrite", kFilePrefix, kMaxFileSize, 3);

   ASSERT_TRUE(stream_->Open());
   WriteAndFlush("a", 0);

   std::string logfile_path = stream_->GetFilePath(0);
   webrtc::FileWrapper f = webrtc::FileWrapper::OpenReadOnly(logfile_path);
   ASSERT_TRUE(f.is_open());
   char buf[1];
   EXPECT_EQ(0u, f.Read(buf, sizeof(buf)));
 }

 // Tests that a write operation followed by a read returns the expected data
 // and writes to the expected files.
 TEST_F(MAYBE_FileRotatingStreamTest, WriteAndRead) {
   Init("FileRotatingStreamTestWriteAndRead", kFilePrefix, kMaxFileSize, 3);

   ASSERT_TRUE(stream_->Open());
   // The test is set up to create three log files of length 2. Write and check
   // contents.
   std::string messages[3] = {"aa", "bb", "cc"};
   for (size_t i = 0; i < arraysize(messages); ++i) {
     const std::string& message = messages[i];
     WriteAndFlush(message.c_str(), message.size());
     // Since the max log size is 2, we will be causing rotation. Read from the
     // next file.
     VerifyFileContents(message.c_str(), message.size(),
                        stream_->GetFilePath(1));
   }
   // Check that exactly three files exist.
   for (size_t i = 0; i < arraysize(messages); ++i) {
     EXPECT_TRUE(webrtc::test::FileExists(stream_->GetFilePath(i)));
   }
   std::string message("d");
   WriteAndFlush(message.c_str(), message.size());
   for (size_t i = 0; i < arraysize(messages); ++i) {
     EXPECT_TRUE(webrtc::test::FileExists(stream_->GetFilePath(i)));
   }
   // TODO(tkchin): Maybe check all the files in the dir.

   // Reopen for read.
   std::string expected_contents("bbccd");
   VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
                    dir_path_, kFilePrefix);
 }

 // Tests that a write operation (with dir name without delimiter) followed by a
 // read returns the expected data and writes to the expected files.
 TEST_F(MAYBE_FileRotatingStreamTest, WriteWithoutDelimiterAndRead) {
   Init("FileRotatingStreamTestWriteWithoutDelimiterAndRead", kFilePrefix,
        kMaxFileSize, 3,
        /* ensure_trailing_delimiter*/ false);

   ASSERT_TRUE(stream_->Open());
   // The test is set up to create three log files of length 2. Write and check
   // contents.
   std::string messages[3] = {"aa", "bb", "cc"};
   for (size_t i = 0; i < arraysize(messages); ++i) {
     const std::string& message = messages[i];
     WriteAndFlush(message.c_str(), message.size());
   }
   std::string message("d");
   WriteAndFlush(message.c_str(), message.size());

   // Reopen for read.
   std::string expected_contents("bbccd");
   VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
                    dir_path_ + webrtc::test::kPathDelimiter, kFilePrefix);
 }

 // Tests that a write operation followed by a read (without trailing delimiter)
 // returns the expected data and writes to the expected files.
 TEST_F(MAYBE_FileRotatingStreamTest, WriteAndReadWithoutDelimiter) {
   Init("FileRotatingStreamTestWriteAndReadWithoutDelimiter", kFilePrefix,
        kMaxFileSize, 3);

   ASSERT_TRUE(stream_->Open());
   // The test is set up to create three log files of length 2. Write and check
   // contents.
   std::string messages[3] = {"aa", "bb", "cc"};
   for (size_t i = 0; i < arraysize(messages); ++i) {
     const std::string& message = messages[i];
     WriteAndFlush(message.c_str(), message.size());
   }
   std::string message("d");
   WriteAndFlush(message.c_str(), message.size());

   // Reopen for read.
   std::string expected_contents("bbccd");
   VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
                    dir_path_.substr(0, dir_path_.size() - 1), kFilePrefix);
 }

 // Tests that writing data greater than the total capacity of the files
 // overwrites the files correctly and is read correctly after.
 TEST_F(MAYBE_FileRotatingStreamTest, WriteOverflowAndRead) {
   Init("FileRotatingStreamTestWriteOverflowAndRead", kFilePrefix, kMaxFileSize,
        3);
   ASSERT_TRUE(stream_->Open());
   // This should cause overflow across all three files, such that the first file
   // we wrote to also gets overwritten.
   std::string message("foobarbaz");
   WriteAndFlush(message.c_str(), message.size());
   std::string expected_file_contents("z");
   VerifyFileContents(expected_file_contents.c_str(),
                      expected_file_contents.size(), stream_->GetFilePath(0));
   std::string expected_stream_contents("arbaz");
   VerifyStreamRead(expected_stream_contents.c_str(),
                    expected_stream_contents.size(), dir_path_, kFilePrefix);
 }

 // Tests that the returned file paths have the right folder and prefix.
 TEST_F(MAYBE_FileRotatingStreamTest, GetFilePath) {
   Init("FileRotatingStreamTestGetFilePath", kFilePrefix, kMaxFileSize, 20);
   // dir_path_ includes a trailing delimiter.
   const std::string prefix = dir_path_ + kFilePrefix;
   for (auto i = 0; i < 20; ++i) {
     EXPECT_EQ(0, stream_->GetFilePath(i).compare(0, prefix.size(), prefix));
   }
 }

 #if defined(WEBRTC_ANDROID)
 // Fails on Android: https://bugs.chromium.org/p/webrtc/issues/detail?id=4364.
 #define MAYBE_CallSessionFileRotatingStreamTest \
   DISABLED_CallSessionFileRotatingStreamTest
 #else
 #define MAYBE_CallSessionFileRotatingStreamTest \
   CallSessionFileRotatingStreamTest
 #endif

 class MAYBE_CallSessionFileRotatingStreamTest : public ::testing::Test {
  protected:
   void Init(const std::string& dir_name, size_t max_total_log_size) {
     dir_path_ = webrtc::test::OutputPath();

     // Append per-test output path in order to run within gtest parallel.
     dir_path_.append(dir_name);
     dir_path_.append(webrtc::test::kPathDelimiter);
     ASSERT_TRUE(webrtc::test::CreateDir(dir_path_));
     stream_.reset(
         new CallSessionFileRotatingStream(dir_path_, max_total_log_size));
   }

   void TearDown() override {
     // On windows, open files can't be removed.
     stream_->Close();
     CleanupLogDirectory(*stream_);
     EXPECT_TRUE(webrtc::test::RemoveDir(dir_path_));

     stream_.reset();
   }

   // Writes the data to the stream and flushes it.
   void WriteAndFlush(const void* data, const size_t data_len) {
     EXPECT_EQ(SR_SUCCESS, stream_->WriteAll(data, data_len, nullptr, nullptr));
     EXPECT_TRUE(stream_->Flush());
   }

   // Checks that the stream reads in the expected contents and then returns an
   // end of stream result.
   void VerifyStreamRead(const char* expected_contents,
                         const size_t expected_length,
                         const std::string& dir_path) {
     CallSessionFileRotatingStreamReader reader(dir_path);
     EXPECT_EQ(reader.GetSize(), expected_length);
     std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
     memset(buffer.get(), 0, expected_length);
     EXPECT_EQ(expected_length, reader.ReadAll(buffer.get(), expected_length));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
   }

   std::unique_ptr<CallSessionFileRotatingStream> stream_;
   std::string dir_path_;
 };

 // Tests that writing and reading to a stream with the smallest possible
 // capacity works.
 TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadSmallest) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadSmallest", 4);

   ASSERT_TRUE(stream_->Open());
   std::string message("abcde");
   WriteAndFlush(message.c_str(), message.size());
   std::string expected_contents("abe");
   VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
                    dir_path_);
 }

 // Tests that writing and reading to a stream with capacity lesser than 4MB
 // behaves correctly.
 TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadSmall) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadSmall", 8);

   ASSERT_TRUE(stream_->Open());
   std::string message("123456789");
   WriteAndFlush(message.c_str(), message.size());
   std::string expected_contents("1234789");
   VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
                    dir_path_);
 }

 // Tests that writing and reading to a stream with capacity greater than 4MB
 // behaves correctly.
 TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadLarge) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadLarge", 6 * 1024 * 1024);

   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   for (int i = 0; i < 8; i++) {
     memset(buffer.get(), i, buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->WriteAll(buffer.get(), buffer_size, nullptr, nullptr));
   }

   const int expected_vals[] = {0, 1, 2, 6, 7};
   const size_t expected_size = buffer_size * arraysize(expected_vals);

   CallSessionFileRotatingStreamReader reader(dir_path_);
   EXPECT_EQ(reader.GetSize(), expected_size);
   std::unique_ptr<uint8_t[]> contents(new uint8_t[expected_size + 1]);
   EXPECT_EQ(reader.ReadAll(contents.get(), expected_size + 1), expected_size);
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     const uint8_t* block = contents.get() + i * buffer_size;
     bool match = true;
     for (size_t j = 0; j < buffer_size; j++) {
       if (block[j] != expected_vals[i]) {
         match = false;
         break;
       }
     }
     // EXPECT call at end of loop, to limit the number of messages on failure.
     EXPECT_TRUE(match);
   }
 }

 // Tests that writing and reading to a stream where only the first file is
 // written to behaves correctly.
 TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadFirstHalf) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadFirstHalf",
        6 * 1024 * 1024);
   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   for (int i = 0; i < 2; i++) {
     memset(buffer.get(), i, buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->WriteAll(buffer.get(), buffer_size, nullptr, nullptr));
   }

   const int expected_vals[] = {0, 1};
   const size_t expected_size = buffer_size * arraysize(expected_vals);

   CallSessionFileRotatingStreamReader reader(dir_path_);
   EXPECT_EQ(reader.GetSize(), expected_size);
   std::unique_ptr<uint8_t[]> contents(new uint8_t[expected_size + 1]);
   EXPECT_EQ(reader.ReadAll(contents.get(), expected_size + 1), expected_size);

   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     const uint8_t* block = contents.get() + i * buffer_size;
     bool match = true;
     for (size_t j = 0; j < buffer_size; j++) {
       if (block[j] != expected_vals[i]) {
         match = false;
         break;
       }
     }
     // EXPECT call at end of loop, to limit the number of messages on failure.
     EXPECT_TRUE(match);
   }
 }

 }  // namespace rtc
	/*
	* Copyright 2015 The WebRTC Project Authors. All rights reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/

	#include <string.h>
	#include <cstdint>
	#include <memory>

	#include "rtc_base/arraysize.h"
	#include "rtc_base/file_rotating_stream.h"
	#include "test/gtest.h"
	#include "test/testsupport/file_utils.h"

	namespace rtc {

	namespace {

	void CleanupLogDirectory(const FileRotatingStream& stream) {
	for (size_t i = 0; i < stream.GetNumFiles(); ++i) {
	// Ignore return value, not all files are expected to exist.
	webrtc::test::RemoveFile(stream.GetFilePath(i));
	}
	}

	} // namespace

	#if defined(WEBRTC_ANDROID)
	// Fails on Android: https://bugs.chromium.org/p/webrtc/issues/detail?id=4364.
	#define MAYBE_FileRotatingStreamTest DISABLED_FileRotatingStreamTest
	#else
	#define MAYBE_FileRotatingStreamTest FileRotatingStreamTest
	#endif

	class MAYBE_FileRotatingStreamTest : public ::testing::Test {
	protected:
	static const char* kFilePrefix;
	static const size_t kMaxFileSize;

	void Init(const std::string& dir_name,
	const std::string& file_prefix,
	size_t max_file_size,
	size_t num_log_files,
	bool ensure_trailing_delimiter = true) {
	dir_path_ = webrtc::test::OutputPath();

	// Append per-test output path in order to run within gtest parallel.
	dir_path_.append(dir_name);
	if (ensure_trailing_delimiter) {
	dir_path_.append(webrtc::test::kPathDelimiter);
	}
	ASSERT_TRUE(webrtc::test::CreateDir(dir_path_));
	stream_.reset(new FileRotatingStream(dir_path_, file_prefix, max_file_size,
	num_log_files));
	}

	void TearDown() override {
	// On windows, open files can't be removed.
	stream_->Close();
	CleanupLogDirectory(*stream_);
	EXPECT_TRUE(webrtc::test::RemoveDir(dir_path_));

	stream_.reset();
	}

	// Writes the data to the stream and flushes it.
	void WriteAndFlush(const void* data, const size_t data_len) {
	EXPECT_EQ(SR_SUCCESS, stream_->WriteAll(data, data_len, nullptr, nullptr));
	EXPECT_TRUE(stream_->Flush());
	}

	// Checks that the stream reads in the expected contents and then returns an
	// end of stream result.
	void VerifyStreamRead(const char* expected_contents,
	const size_t expected_length,
	const std::string& dir_path,
	const char* file_prefix) {
	FileRotatingStreamReader reader(dir_path, file_prefix);
	EXPECT_EQ(reader.GetSize(), expected_length);
	std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
	memset(buffer.get(), 0, expected_length);
	EXPECT_EQ(expected_length, reader.ReadAll(buffer.get(), expected_length));
	EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
	}

	void VerifyFileContents(const char* expected_contents,
	const size_t expected_length,
	const std::string& file_path) {
	std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length + 1]);
	webrtc::FileWrapper f = webrtc::FileWrapper::OpenReadOnly(file_path);
	ASSERT_TRUE(f.is_open());
	size_t size_read = f.Read(buffer.get(), expected_length + 1);
	EXPECT_EQ(size_read, expected_length);
	EXPECT_EQ(0, memcmp(expected_contents, buffer.get(),
	std::min(expected_length, size_read)));
	}

	std::unique_ptr<FileRotatingStream> stream_;
	std::string dir_path_;
	};

	const char* MAYBE_FileRotatingStreamTest::kFilePrefix =
	"FileRotatingStreamTest";
	const size_t MAYBE_FileRotatingStreamTest::kMaxFileSize = 2;

	// Tests that stream state is correct before and after Open / Close.
	TEST_F(MAYBE_FileRotatingStreamTest, State) {
	Init("FileRotatingStreamTestState", kFilePrefix, kMaxFileSize, 3);

	EXPECT_EQ(SS_CLOSED, stream_->GetState());
	ASSERT_TRUE(stream_->Open());
	EXPECT_EQ(SS_OPEN, stream_->GetState());
	stream_->Close();
	EXPECT_EQ(SS_CLOSED, stream_->GetState());
	}

	// Tests that nothing is written to file when data of length zero is written.
	TEST_F(MAYBE_FileRotatingStreamTest, EmptyWrite) {
	Init("FileRotatingStreamTestEmptyWrite", kFilePrefix, kMaxFileSize, 3);

	ASSERT_TRUE(stream_->Open());
	WriteAndFlush("a", 0);

	std::string logfile_path = stream_->GetFilePath(0);
	webrtc::FileWrapper f = webrtc::FileWrapper::OpenReadOnly(logfile_path);
	ASSERT_TRUE(f.is_open());
	char buf[1];
	EXPECT_EQ(0u, f.Read(buf, sizeof(buf)));
	}

	// Tests that a write operation followed by a read returns the expected data
	// and writes to the expected files.
	TEST_F(MAYBE_FileRotatingStreamTest, WriteAndRead) {
	Init("FileRotatingStreamTestWriteAndRead", kFilePrefix, kMaxFileSize, 3);

	ASSERT_TRUE(stream_->Open());
	// The test is set up to create three log files of length 2. Write and check
	// contents.
	std::string messages[3] = {"aa", "bb", "cc"};
	for (size_t i = 0; i < arraysize(messages); ++i) {
	const std::string& message = messages[i];
	WriteAndFlush(message.c_str(), message.size());
	// Since the max log size is 2, we will be causing rotation. Read from the
	// next file.
	VerifyFileContents(message.c_str(), message.size(),
	stream_->GetFilePath(1));
	}
	// Check that exactly three files exist.
	for (size_t i = 0; i < arraysize(messages); ++i) {
	EXPECT_TRUE(webrtc::test::FileExists(stream_->GetFilePath(i)));
	}
	std::string message("d");
	WriteAndFlush(message.c_str(), message.size());
	for (size_t i = 0; i < arraysize(messages); ++i) {
	EXPECT_TRUE(webrtc::test::FileExists(stream_->GetFilePath(i)));
	}
	// TODO(tkchin): Maybe check all the files in the dir.

	// Reopen for read.
	std::string expected_contents("bbccd");
	VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
	dir_path_, kFilePrefix);
	}

	// Tests that a write operation (with dir name without delimiter) followed by a
	// read returns the expected data and writes to the expected files.
	TEST_F(MAYBE_FileRotatingStreamTest, WriteWithoutDelimiterAndRead) {
	Init("FileRotatingStreamTestWriteWithoutDelimiterAndRead", kFilePrefix,
	kMaxFileSize, 3,
	/* ensure_trailing_delimiter*/ false);

	ASSERT_TRUE(stream_->Open());
	// The test is set up to create three log files of length 2. Write and check
	// contents.
	std::string messages[3] = {"aa", "bb", "cc"};
	for (size_t i = 0; i < arraysize(messages); ++i) {
	const std::string& message = messages[i];
	WriteAndFlush(message.c_str(), message.size());
	}
	std::string message("d");
	WriteAndFlush(message.c_str(), message.size());

	// Reopen for read.
	std::string expected_contents("bbccd");
	VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
	dir_path_ + webrtc::test::kPathDelimiter, kFilePrefix);
	}

	// Tests that a write operation followed by a read (without trailing delimiter)
	// returns the expected data and writes to the expected files.
	TEST_F(MAYBE_FileRotatingStreamTest, WriteAndReadWithoutDelimiter) {
	Init("FileRotatingStreamTestWriteAndReadWithoutDelimiter", kFilePrefix,
	kMaxFileSize, 3);

	ASSERT_TRUE(stream_->Open());
	// The test is set up to create three log files of length 2. Write and check
	// contents.
	std::string messages[3] = {"aa", "bb", "cc"};
	for (size_t i = 0; i < arraysize(messages); ++i) {
	const std::string& message = messages[i];
	WriteAndFlush(message.c_str(), message.size());
	}
	std::string message("d");
	WriteAndFlush(message.c_str(), message.size());

	// Reopen for read.
	std::string expected_contents("bbccd");
	VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
	dir_path_.substr(0, dir_path_.size() - 1), kFilePrefix);
	}

	// Tests that writing data greater than the total capacity of the files
	// overwrites the files correctly and is read correctly after.
	TEST_F(MAYBE_FileRotatingStreamTest, WriteOverflowAndRead) {
	Init("FileRotatingStreamTestWriteOverflowAndRead", kFilePrefix, kMaxFileSize,
	3);
	ASSERT_TRUE(stream_->Open());
	// This should cause overflow across all three files, such that the first file
	// we wrote to also gets overwritten.
	std::string message("foobarbaz");
	WriteAndFlush(message.c_str(), message.size());
	std::string expected_file_contents("z");
	VerifyFileContents(expected_file_contents.c_str(),
	expected_file_contents.size(), stream_->GetFilePath(0));
	std::string expected_stream_contents("arbaz");
	VerifyStreamRead(expected_stream_contents.c_str(),
	expected_stream_contents.size(), dir_path_, kFilePrefix);
	}

	// Tests that the returned file paths have the right folder and prefix.
	TEST_F(MAYBE_FileRotatingStreamTest, GetFilePath) {
	Init("FileRotatingStreamTestGetFilePath", kFilePrefix, kMaxFileSize, 20);
	// dir_path_ includes a trailing delimiter.
	const std::string prefix = dir_path_ + kFilePrefix;
	for (auto i = 0; i < 20; ++i) {
	EXPECT_EQ(0, stream_->GetFilePath(i).compare(0, prefix.size(), prefix));
	}
	}

	#if defined(WEBRTC_ANDROID)
	// Fails on Android: https://bugs.chromium.org/p/webrtc/issues/detail?id=4364.
	#define MAYBE_CallSessionFileRotatingStreamTest \
	DISABLED_CallSessionFileRotatingStreamTest
	#else
	#define MAYBE_CallSessionFileRotatingStreamTest \
	CallSessionFileRotatingStreamTest
	#endif

	class MAYBE_CallSessionFileRotatingStreamTest : public ::testing::Test {
	protected:
	void Init(const std::string& dir_name, size_t max_total_log_size) {
	dir_path_ = webrtc::test::OutputPath();

	// Append per-test output path in order to run within gtest parallel.
	dir_path_.append(dir_name);
	dir_path_.append(webrtc::test::kPathDelimiter);
	ASSERT_TRUE(webrtc::test::CreateDir(dir_path_));
	stream_.reset(
	new CallSessionFileRotatingStream(dir_path_, max_total_log_size));
	}

	void TearDown() override {
	// On windows, open files can't be removed.
	stream_->Close();
	CleanupLogDirectory(*stream_);
	EXPECT_TRUE(webrtc::test::RemoveDir(dir_path_));

	stream_.reset();
	}

	// Writes the data to the stream and flushes it.
	void WriteAndFlush(const void* data, const size_t data_len) {
	EXPECT_EQ(SR_SUCCESS, stream_->WriteAll(data, data_len, nullptr, nullptr));
	EXPECT_TRUE(stream_->Flush());
	}

	// Checks that the stream reads in the expected contents and then returns an
	// end of stream result.
	void VerifyStreamRead(const char* expected_contents,
	const size_t expected_length,
	const std::string& dir_path) {
	CallSessionFileRotatingStreamReader reader(dir_path);
	EXPECT_EQ(reader.GetSize(), expected_length);
	std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
	memset(buffer.get(), 0, expected_length);
	EXPECT_EQ(expected_length, reader.ReadAll(buffer.get(), expected_length));
	EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
	}

	std::unique_ptr<CallSessionFileRotatingStream> stream_;
	std::string dir_path_;
	};

	// Tests that writing and reading to a stream with the smallest possible
	// capacity works.
	TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadSmallest) {
	Init("CallSessionFileRotatingStreamTestWriteAndReadSmallest", 4);

	ASSERT_TRUE(stream_->Open());
	std::string message("abcde");
	WriteAndFlush(message.c_str(), message.size());
	std::string expected_contents("abe");
	VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
	dir_path_);
	}

	// Tests that writing and reading to a stream with capacity lesser than 4MB
	// behaves correctly.
	TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadSmall) {
	Init("CallSessionFileRotatingStreamTestWriteAndReadSmall", 8);

	ASSERT_TRUE(stream_->Open());
	std::string message("123456789");
	WriteAndFlush(message.c_str(), message.size());
	std::string expected_contents("1234789");
	VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
	dir_path_);
	}

	// Tests that writing and reading to a stream with capacity greater than 4MB
	// behaves correctly.
	TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadLarge) {
	Init("CallSessionFileRotatingStreamTestWriteAndReadLarge", 6 * 1024 * 1024);

	ASSERT_TRUE(stream_->Open());
	const size_t buffer_size = 1024 * 1024;
	std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
	for (int i = 0; i < 8; i++) {
	memset(buffer.get(), i, buffer_size);
	EXPECT_EQ(SR_SUCCESS,
	stream_->WriteAll(buffer.get(), buffer_size, nullptr, nullptr));
	}

	const int expected_vals[] = {0, 1, 2, 6, 7};
	const size_t expected_size = buffer_size * arraysize(expected_vals);

	CallSessionFileRotatingStreamReader reader(dir_path_);
	EXPECT_EQ(reader.GetSize(), expected_size);
	std::unique_ptr<uint8_t[]> contents(new uint8_t[expected_size + 1]);
	EXPECT_EQ(reader.ReadAll(contents.get(), expected_size + 1), expected_size);
	for (size_t i = 0; i < arraysize(expected_vals); ++i) {
	const uint8_t* block = contents.get() + i * buffer_size;
	bool match = true;
	for (size_t j = 0; j < buffer_size; j++) {
	if (block[j] != expected_vals[i]) {
	match = false;
	break;
	}
	}
	// EXPECT call at end of loop, to limit the number of messages on failure.
	EXPECT_TRUE(match);
	}
	}

	// Tests that writing and reading to a stream where only the first file is
	// written to behaves correctly.
	TEST_F(MAYBE_CallSessionFileRotatingStreamTest, WriteAndReadFirstHalf) {
	Init("CallSessionFileRotatingStreamTestWriteAndReadFirstHalf",
	6 * 1024 * 1024);
	ASSERT_TRUE(stream_->Open());
	const size_t buffer_size = 1024 * 1024;
	std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
	for (int i = 0; i < 2; i++) {
	memset(buffer.get(), i, buffer_size);
	EXPECT_EQ(SR_SUCCESS,
	stream_->WriteAll(buffer.get(), buffer_size, nullptr, nullptr));
	}

	const int expected_vals[] = {0, 1};
	const size_t expected_size = buffer_size * arraysize(expected_vals);

	CallSessionFileRotatingStreamReader reader(dir_path_);
	EXPECT_EQ(reader.GetSize(), expected_size);
	std::unique_ptr<uint8_t[]> contents(new uint8_t[expected_size + 1]);
	EXPECT_EQ(reader.ReadAll(contents.get(), expected_size + 1), expected_size);

	for (size_t i = 0; i < arraysize(expected_vals); ++i) {
	const uint8_t* block = contents.get() + i * buffer_size;
	bool match = true;
	for (size_t j = 0; j < buffer_size; j++) {
	if (block[j] != expected_vals[i]) {
	match = false;
	break;
	}
	}
	// EXPECT call at end of loop, to limit the number of messages on failure.
	EXPECT_TRUE(match);
	}
	}

	} // namespace rtc