base/filerotatingstream_unittest.cc - src/webrtc - 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 "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/filerotatingstream.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/pathutils.h"

 namespace rtc {

 class 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) {
     Pathname test_path;
     ASSERT_TRUE(Filesystem::GetAppTempFolder(&test_path));
     // Append per-test output path in order to run within gtest parallel.
     test_path.AppendFolder(dir_name);
     ASSERT_TRUE(Filesystem::CreateFolder(test_path));
     dir_path_ = test_path.pathname();
     ASSERT_TRUE(dir_path_.size());
     stream_.reset(new FileRotatingStream(dir_path_, file_prefix, max_file_size,
                                          num_log_files));
   }

   void TearDown() override {
     stream_.reset();
     if (dir_path_.size() && Filesystem::IsFolder(dir_path_) &&
         Filesystem::IsTemporaryPath(dir_path_)) {
       Filesystem::DeleteFolderAndContents(dir_path_);
     }
   }

   // 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) {
     scoped_ptr<FileRotatingStream> stream;
     stream.reset(new FileRotatingStream(dir_path, file_prefix));
     ASSERT_TRUE(stream->Open());
     size_t read = 0;
     size_t stream_size = 0;
     EXPECT_TRUE(stream->GetSize(&stream_size));
     scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
     EXPECT_EQ(SR_SUCCESS,
               stream->ReadAll(buffer.get(), expected_length, &read, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
     EXPECT_EQ(SR_EOS, stream->ReadAll(buffer.get(), 1, nullptr, nullptr));
     EXPECT_EQ(stream_size, read);
   }

   void VerifyFileContents(const char* expected_contents,
                           const size_t expected_length,
                           const std::string& file_path) {
     scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
     scoped_ptr<FileStream> stream(Filesystem::OpenFile(file_path, "r"));
     EXPECT_TRUE(stream);
     if (!stream) {
       return;
     }
     EXPECT_EQ(rtc::SR_SUCCESS,
               stream->ReadAll(buffer.get(), expected_length, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
     size_t file_size = 0;
     EXPECT_TRUE(stream->GetSize(&file_size));
     EXPECT_EQ(file_size, expected_length);
   }

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

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

 // Tests that stream state is correct before and after Open / Close.
 TEST_F(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(FileRotatingStreamTest, EmptyWrite) {
   Init("FileRotatingStreamTestEmptyWrite", kFilePrefix, kMaxFileSize, 3);

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

   std::string logfile_path = stream_->GetFilePath(0);
   scoped_ptr<FileStream> stream(Filesystem::OpenFile(logfile_path, "r"));
   size_t file_size = 0;
   EXPECT_TRUE(stream->GetSize(&file_size));
   EXPECT_EQ(0u, file_size);
 }

 // Tests that a write operation followed by a read returns the expected data
 // and writes to the expected files.
 TEST_F(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(Filesystem::IsFile(stream_->GetFilePath(i)));
   }
   std::string message("d");
   WriteAndFlush(message.c_str(), message.size());
   for (size_t i = 0; i < arraysize(messages); ++i) {
     EXPECT_TRUE(Filesystem::IsFile(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 writing data greater than the total capacity of the files
 // overwrites the files correctly and is read correctly after.
 TEST_F(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(FileRotatingStreamTest, GetFilePath) {
   Init("FileRotatingStreamTestGetFilePath", kFilePrefix, kMaxFileSize, 20);
   for (auto i = 0; i < 20; ++i) {
     Pathname path(stream_->GetFilePath(i));
     EXPECT_EQ(0, path.folder().compare(dir_path_));
     EXPECT_EQ(0, path.filename().compare(0, strlen(kFilePrefix), kFilePrefix));
   }
 }

 class CallSessionFileRotatingStreamTest : public ::testing::Test {
  protected:
   void Init(const std::string& dir_name, size_t max_total_log_size) {
     Pathname test_path;
     ASSERT_TRUE(Filesystem::GetAppTempFolder(&test_path));
     // Append per-test output path in order to run within gtest parallel.
     test_path.AppendFolder(dir_name);
     ASSERT_TRUE(Filesystem::CreateFolder(test_path));
     dir_path_ = test_path.pathname();
     ASSERT_TRUE(dir_path_.size());
     stream_.reset(
         new CallSessionFileRotatingStream(dir_path_, max_total_log_size));
   }

   virtual void TearDown() {
     stream_.reset();
     if (dir_path_.size() && Filesystem::IsFolder(dir_path_) &&
         Filesystem::IsTemporaryPath(dir_path_)) {
       Filesystem::DeleteFolderAndContents(dir_path_);
     }
   }

   // 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) {
     scoped_ptr<CallSessionFileRotatingStream> stream(
         new CallSessionFileRotatingStream(dir_path));
     ASSERT_TRUE(stream->Open());
     size_t read = 0;
     size_t stream_size = 0;
     EXPECT_TRUE(stream->GetSize(&stream_size));
     scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
     EXPECT_EQ(SR_SUCCESS,
               stream->ReadAll(buffer.get(), expected_length, &read, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
     EXPECT_EQ(SR_EOS, stream->ReadAll(buffer.get(), 1, nullptr, nullptr));
     EXPECT_EQ(stream_size, read);
   }

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

 // Tests that writing and reading to a stream with the smallest possible
 // capacity works.
 TEST_F(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(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(CallSessionFileRotatingStreamTest, WriteAndReadLarge) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadLarge", 6 * 1024 * 1024);

   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
   scoped_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));
   }

   stream_.reset(new CallSessionFileRotatingStream(dir_path_));
   ASSERT_TRUE(stream_->Open());
   scoped_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
   int expected_vals[] = {0, 1, 2, 6, 7};
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     memset(expected_buffer.get(), expected_vals[i], buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->ReadAll(buffer.get(), buffer_size, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(buffer.get(), expected_buffer.get(), buffer_size));
   }
   EXPECT_EQ(SR_EOS, stream_->ReadAll(buffer.get(), 1, nullptr, nullptr));
 }

 // Tests that writing and reading to a stream where only the first file is
 // written to behaves correctly.
 TEST_F(CallSessionFileRotatingStreamTest, WriteAndReadFirstHalf) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadFirstHalf",
        6 * 1024 * 1024);
   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
   scoped_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));
   }

   stream_.reset(new CallSessionFileRotatingStream(dir_path_));
   ASSERT_TRUE(stream_->Open());
   scoped_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
   int expected_vals[] = {0, 1};
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     memset(expected_buffer.get(), expected_vals[i], buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->ReadAll(buffer.get(), buffer_size, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(buffer.get(), expected_buffer.get(), buffer_size));
   }
   EXPECT_EQ(SR_EOS, stream_->ReadAll(buffer.get(), 1, nullptr, nullptr));
 }

 }  // 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 "webrtc/base/arraysize.h"
	#include "webrtc/base/checks.h"
	#include "webrtc/base/filerotatingstream.h"
	#include "webrtc/base/fileutils.h"
	#include "webrtc/base/gunit.h"
	#include "webrtc/base/pathutils.h"

	namespace rtc {

	class 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) {
	Pathname test_path;
	ASSERT_TRUE(Filesystem::GetAppTempFolder(&test_path));
	// Append per-test output path in order to run within gtest parallel.
	test_path.AppendFolder(dir_name);
	ASSERT_TRUE(Filesystem::CreateFolder(test_path));
	dir_path_ = test_path.pathname();
	ASSERT_TRUE(dir_path_.size());
	stream_.reset(new FileRotatingStream(dir_path_, file_prefix, max_file_size,
	num_log_files));
	}

	void TearDown() override {
	stream_.reset();
	if (dir_path_.size() && Filesystem::IsFolder(dir_path_) &&
	Filesystem::IsTemporaryPath(dir_path_)) {
	Filesystem::DeleteFolderAndContents(dir_path_);
	}
	}

	// 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) {
	scoped_ptr<FileRotatingStream> stream;
	stream.reset(new FileRotatingStream(dir_path, file_prefix));
	ASSERT_TRUE(stream->Open());
	size_t read = 0;
	size_t stream_size = 0;
	EXPECT_TRUE(stream->GetSize(&stream_size));
	scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
	EXPECT_EQ(SR_SUCCESS,
	stream->ReadAll(buffer.get(), expected_length, &read, nullptr));
	EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
	EXPECT_EQ(SR_EOS, stream->ReadAll(buffer.get(), 1, nullptr, nullptr));
	EXPECT_EQ(stream_size, read);
	}

	void VerifyFileContents(const char* expected_contents,
	const size_t expected_length,
	const std::string& file_path) {
	scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
	scoped_ptr<FileStream> stream(Filesystem::OpenFile(file_path, "r"));
	EXPECT_TRUE(stream);
	if (!stream) {
	return;
	}
	EXPECT_EQ(rtc::SR_SUCCESS,
	stream->ReadAll(buffer.get(), expected_length, nullptr, nullptr));
	EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
	size_t file_size = 0;
	EXPECT_TRUE(stream->GetSize(&file_size));
	EXPECT_EQ(file_size, expected_length);
	}

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

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

	// Tests that stream state is correct before and after Open / Close.
	TEST_F(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(FileRotatingStreamTest, EmptyWrite) {
	Init("FileRotatingStreamTestEmptyWrite", kFilePrefix, kMaxFileSize, 3);

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

	std::string logfile_path = stream_->GetFilePath(0);
	scoped_ptr<FileStream> stream(Filesystem::OpenFile(logfile_path, "r"));
	size_t file_size = 0;
	EXPECT_TRUE(stream->GetSize(&file_size));
	EXPECT_EQ(0u, file_size);
	}

	// Tests that a write operation followed by a read returns the expected data
	// and writes to the expected files.
	TEST_F(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(Filesystem::IsFile(stream_->GetFilePath(i)));
	}
	std::string message("d");
	WriteAndFlush(message.c_str(), message.size());
	for (size_t i = 0; i < arraysize(messages); ++i) {
	EXPECT_TRUE(Filesystem::IsFile(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 writing data greater than the total capacity of the files
	// overwrites the files correctly and is read correctly after.
	TEST_F(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(FileRotatingStreamTest, GetFilePath) {
	Init("FileRotatingStreamTestGetFilePath", kFilePrefix, kMaxFileSize, 20);
	for (auto i = 0; i < 20; ++i) {
	Pathname path(stream_->GetFilePath(i));
	EXPECT_EQ(0, path.folder().compare(dir_path_));
	EXPECT_EQ(0, path.filename().compare(0, strlen(kFilePrefix), kFilePrefix));
	}
	}

	class CallSessionFileRotatingStreamTest : public ::testing::Test {
	protected:
	void Init(const std::string& dir_name, size_t max_total_log_size) {
	Pathname test_path;
	ASSERT_TRUE(Filesystem::GetAppTempFolder(&test_path));
	// Append per-test output path in order to run within gtest parallel.
	test_path.AppendFolder(dir_name);
	ASSERT_TRUE(Filesystem::CreateFolder(test_path));
	dir_path_ = test_path.pathname();
	ASSERT_TRUE(dir_path_.size());
	stream_.reset(
	new CallSessionFileRotatingStream(dir_path_, max_total_log_size));
	}

	virtual void TearDown() {
	stream_.reset();
	if (dir_path_.size() && Filesystem::IsFolder(dir_path_) &&
	Filesystem::IsTemporaryPath(dir_path_)) {
	Filesystem::DeleteFolderAndContents(dir_path_);
	}
	}

	// 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) {
	scoped_ptr<CallSessionFileRotatingStream> stream(
	new CallSessionFileRotatingStream(dir_path));
	ASSERT_TRUE(stream->Open());
	size_t read = 0;
	size_t stream_size = 0;
	EXPECT_TRUE(stream->GetSize(&stream_size));
	scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
	EXPECT_EQ(SR_SUCCESS,
	stream->ReadAll(buffer.get(), expected_length, &read, nullptr));
	EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
	EXPECT_EQ(SR_EOS, stream->ReadAll(buffer.get(), 1, nullptr, nullptr));
	EXPECT_EQ(stream_size, read);
	}

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

	// Tests that writing and reading to a stream with the smallest possible
	// capacity works.
	TEST_F(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(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(CallSessionFileRotatingStreamTest, WriteAndReadLarge) {
	Init("CallSessionFileRotatingStreamTestWriteAndReadLarge", 6 * 1024 * 1024);

	ASSERT_TRUE(stream_->Open());
	const size_t buffer_size = 1024 * 1024;
	scoped_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));
	}

	stream_.reset(new CallSessionFileRotatingStream(dir_path_));
	ASSERT_TRUE(stream_->Open());
	scoped_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
	int expected_vals[] = {0, 1, 2, 6, 7};
	for (size_t i = 0; i < arraysize(expected_vals); ++i) {
	memset(expected_buffer.get(), expected_vals[i], buffer_size);
	EXPECT_EQ(SR_SUCCESS,
	stream_->ReadAll(buffer.get(), buffer_size, nullptr, nullptr));
	EXPECT_EQ(0, memcmp(buffer.get(), expected_buffer.get(), buffer_size));
	}
	EXPECT_EQ(SR_EOS, stream_->ReadAll(buffer.get(), 1, nullptr, nullptr));
	}

	// Tests that writing and reading to a stream where only the first file is
	// written to behaves correctly.
	TEST_F(CallSessionFileRotatingStreamTest, WriteAndReadFirstHalf) {
	Init("CallSessionFileRotatingStreamTestWriteAndReadFirstHalf",
	6 * 1024 * 1024);
	ASSERT_TRUE(stream_->Open());
	const size_t buffer_size = 1024 * 1024;
	scoped_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));
	}

	stream_.reset(new CallSessionFileRotatingStream(dir_path_));
	ASSERT_TRUE(stream_->Open());
	scoped_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
	int expected_vals[] = {0, 1};
	for (size_t i = 0; i < arraysize(expected_vals); ++i) {
	memset(expected_buffer.get(), expected_vals[i], buffer_size);
	EXPECT_EQ(SR_SUCCESS,
	stream_->ReadAll(buffer.get(), buffer_size, nullptr, nullptr));
	EXPECT_EQ(0, memcmp(buffer.get(), expected_buffer.get(), buffer_size));
	}
	EXPECT_EQ(SR_EOS, stream_->ReadAll(buffer.get(), 1, nullptr, nullptr));
	}

	} // namespace rtc