AU: Speed up updates by using buffered writes.

buffered_file_writer_unittest.cc

Index: buffered_file_writer_unittest.cc
diff --git a/buffered_file_writer_unittest.cc b/buffered_file_writer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1c39a4e87f0f01b3118a26c1674504e81411ed5f
--- /dev/null
+++ b/buffered_file_writer_unittest.cc
@@ -0,0 +1,132 @@
+// Copyright (c) 2010 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 <gtest/gtest.h>
+
+#include "update_engine/buffered_file_writer.h"
+#include "update_engine/file_writer_mock.h"
+
+using std::string;
+using testing::_;
+using testing::InSequence;
+using testing::Return;
+
+namespace chromeos_update_engine {
+
+static const int kTestFlags = O_CREAT | O_LARGEFILE | O_TRUNC | O_WRONLY;
+static const mode_t kTestMode = 0644;
+
+MATCHER_P2(MemCmp, expected, n, "") { return memcmp(arg, expected, n) == 0; }
+
+class BufferedFileWriterTest : public ::testing::Test {
+ protected:
+  FileWriterMock file_writer_mock_;
+};
+
+TEST_F(BufferedFileWriterTest, CloseErrorTest) {
+  BufferedFileWriter writer(&file_writer_mock_, 100);
+  writer.buffered_bytes_ = 1;
+  InSequence s;
+  EXPECT_CALL(file_writer_mock_, Write(&writer.buffer_[0], 1))
+      .Times(1)
+      .WillOnce(Return(50));
+  EXPECT_CALL(file_writer_mock_, Close()).Times(1).WillOnce(Return(-20));
+  EXPECT_EQ(-20, writer.Close());
+}
+
+TEST_F(BufferedFileWriterTest, CloseNoDataTest) {
+  BufferedFileWriter writer(&file_writer_mock_, 50);
+  InSequence s;
+  EXPECT_CALL(file_writer_mock_, Write(_, _)).Times(0);
+  EXPECT_CALL(file_writer_mock_, Close()).Times(1).WillOnce(Return(-30));
+  EXPECT_EQ(-30, writer.Close());
+}
+
+TEST_F(BufferedFileWriterTest, CloseWriteErrorTest) {
+  BufferedFileWriter writer(&file_writer_mock_, 100);
+  writer.buffered_bytes_ = 2;
+  InSequence s;
+  EXPECT_CALL(file_writer_mock_, Write(&writer.buffer_[0], 2))
+      .Times(1)
+      .WillOnce(Return(-10));
+  EXPECT_CALL(file_writer_mock_, Close()).Times(1).WillOnce(Return(-20));
+  EXPECT_EQ(-10, writer.Close());
+}
+
+TEST_F(BufferedFileWriterTest, ConstructorTest) {
+  BufferedFileWriter writer(&file_writer_mock_, 123);
+  EXPECT_EQ(&file_writer_mock_, writer.next_);
+  EXPECT_EQ(123, writer.buffer_size_);
+  EXPECT_TRUE(writer.buffer_ != NULL);
+  EXPECT_EQ(0, writer.buffered_bytes_);
+}
+
+TEST_F(BufferedFileWriterTest, OpenTest) {
+  BufferedFileWriter writer(&file_writer_mock_, 100);
+  EXPECT_CALL(file_writer_mock_, Open("foo", kTestFlags, kTestMode))
+      .Times(1)
+      .WillOnce(Return(20));
+  EXPECT_EQ(20, writer.Open("foo", kTestFlags, kTestMode));
+}
+
+TEST_F(BufferedFileWriterTest, WriteBufferNoDataTest) {
+  BufferedFileWriter writer(&file_writer_mock_, 300);
+  EXPECT_CALL(file_writer_mock_, Write(_, _)).Times(0);
+  EXPECT_EQ(0, writer.WriteBuffer());
+}
+
+TEST_F(BufferedFileWriterTest, WriteBufferTest) {
+  BufferedFileWriter writer(&file_writer_mock_, 200);
+  writer.buffered_bytes_ = 100;
+  EXPECT_CALL(file_writer_mock_, Write(&writer.buffer_[0], 100))
+      .Times(1)
+      .WillOnce(Return(-10));
+  EXPECT_EQ(-10, writer.WriteBuffer());
+}
+
+TEST_F(BufferedFileWriterTest, WriteErrorTest) {
+  string kData = "test_data";
+  BufferedFileWriter writer(&file_writer_mock_, 4);
+  InSequence s;
+  EXPECT_CALL(file_writer_mock_, Write(MemCmp("test", 4), 4))
+      .Times(1)
+      .WillOnce(Return(3));
+  EXPECT_CALL(file_writer_mock_, Write(MemCmp("_dat", 4), 4))
+      .Times(1)
+      .WillOnce(Return(-10));
+  EXPECT_EQ(-10, writer.Write(kData.data(), kData.size()));
+  EXPECT_EQ(0, writer.buffered_bytes_);
+}
+
+TEST_F(BufferedFileWriterTest, WriteTest) {
+  string kData = "test_data";
+  BufferedFileWriter writer(&file_writer_mock_, 100);
+  writer.buffered_bytes_ = 10;
+  EXPECT_CALL(file_writer_mock_, Write(_, _)).Times(0);
+  EXPECT_EQ(kData.size(), writer.Write(kData.data(), kData.size()));
+  EXPECT_EQ(0, memcmp(kData.data(), &writer.buffer_[10], kData.size()));
+  EXPECT_EQ(kData.size() + 10, writer.buffered_bytes_);
+}
+
+TEST_F(BufferedFileWriterTest, WriteWrapBufferTest) {
+  string kData = "test_data1";
+  BufferedFileWriter writer(&file_writer_mock_, 3);
+  writer.buffered_bytes_ = 1;
+  writer.buffer_[0] = 'x';
+  InSequence s;
+  EXPECT_CALL(file_writer_mock_, Write(MemCmp("xte", 3), 3))
+      .Times(1)
+      .WillOnce(Return(3));
+  EXPECT_CALL(file_writer_mock_, Write(MemCmp("st_", 3), 3))
+      .Times(1)
+      .WillOnce(Return(3));
+  EXPECT_CALL(file_writer_mock_, Write(MemCmp("dat", 3), 3))
+      .Times(1)
+      .WillOnce(Return(3));
+  EXPECT_EQ(kData.size(), writer.Write(kData.data(), kData.size()));
+  EXPECT_EQ(0, memcmp("a1", &writer.buffer_[0], 2));
+  EXPECT_EQ(2, writer.buffered_bytes_);
+}
+
+}  // namespace chromeos_update_engine