AU: Try delta updates first, then full updates

src/platform/update_engine/delta_diff_generator_unittest.cc

 // Copyright (c) 2009 The Chromium 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 <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <set>
 #include <string>
 #include <vector>
 #include "base/string_util.h"
 #include <gtest/gtest.h>
 #include "chromeos/obsolete_logging.h"
 #include "update_engine/decompressing_file_writer.h"
 #include "update_engine/delta_diff_generator.h"
 #include "update_engine/delta_diff_parser.h"
 #include "update_engine/gzip.h"
 #include "update_engine/mock_file_writer.h"
 #include "update_engine/subprocess.h"
 #include "update_engine/test_utils.h"
 #include "update_engine/utils.h"
 
 namespace chromeos_update_engine {
 
+using std::set;
 using std::string;
 using std::vector;
 
-class DeltaDiffGeneratorTest : public ::testing::Test {};
+class DeltaDiffGeneratorTest : public ::testing::Test {
+  virtual void TearDown() {
+    EXPECT_EQ(0, system("rm -rf diff-gen-test"));
+  }
+protected:
+  void FakerootEncodeDataToDeltaFileTest(bool test_diff_exclusion);
+};
 
 namespace {
 void DumpProto(const DeltaArchiveManifest* archive) {
   for (int i = 0; i < archive->files_size(); i++) {
     printf("Node %d\n", i);
     const DeltaArchiveManifest_File& file = archive->files(i);
     for (int j = 0; j < file.children_size(); j++) {
       const DeltaArchiveManifest_File_Child& child = file.children(j);
       printf("  %d %s\n", child.index(), child.name().c_str());
     }
@@ skipping 304 matching lines @@
   EXPECT_TRUE(S_ISLNK(link.mode()));
   EXPECT_EQ(0, link.uid());
   EXPECT_EQ(0, link.gid());
   EXPECT_FALSE(link.has_hardlink_path());
   EXPECT_FALSE(link.has_data_format());
   EXPECT_FALSE(link.has_data_offset());
   EXPECT_FALSE(link.has_data_length());
 }
 
 TEST_F(DeltaDiffGeneratorTest, FakerootEncodeDataToDeltaFileTest) {
+  FakerootEncodeDataToDeltaFileTest(false);
+}
+TEST_F(DeltaDiffGeneratorTest, FakerootDiffExclusionsTest) {
+  FakerootEncodeDataToDeltaFileTest(true);
+}
+
+void DeltaDiffGeneratorTest::FakerootEncodeDataToDeltaFileTest(
+    bool test_diff_exclusion) {
   char cwd[1000];
   ASSERT_EQ(cwd, getcwd(cwd, sizeof(cwd))) << "cwd buf possibly too small";
   ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test"));
   ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test/old"));
   ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test/new"));
   GenerateFilesAtPath(string(cwd) + "/diff-gen-test/old");
   GenerateFilesAtPath(string(cwd) + "/diff-gen-test/new");
   EditFilesAtPath(string(cwd) + "/diff-gen-test/new");
 
+  set<string> diff_exclusions;
+  if (test_diff_exclusion) {
+    diff_exclusions.insert("/encoding/long_small_change");
+  } else {
+    diff_exclusions.insert("/hi");
+  }
+
   DeltaArchiveManifest* archive =
       DeltaDiffGenerator::EncodeMetadataToProtoBuffer(
           (string(cwd) + "/diff-gen-test/new").c_str());
   EXPECT_TRUE(NULL != archive);
 
   EXPECT_TRUE(DeltaDiffGenerator::EncodeDataToDeltaFile(
       archive,
       string(cwd) + "/diff-gen-test/old",
       string(cwd) + "/diff-gen-test/new",
       string(cwd) + "/diff-gen-test/out.dat",
-      ""));
+      diff_exclusions, ""));
 
   EXPECT_EQ(18, archive->files_size());
 
   const DeltaArchiveManifest_File& root = archive->files(0);
   EXPECT_TRUE(S_ISDIR(root.mode()));
   EXPECT_EQ(0, root.uid());
   EXPECT_EQ(0, root.gid());
   ASSERT_EQ(6, root.children_size());
   EXPECT_EQ("cdev", root.children(0).name());
   EXPECT_EQ("compress_link", root.children(1).name());
@@ skipping 86 matching lines @@
   EXPECT_TRUE(long_new.has_data_length());
   EXPECT_FALSE(long_new.has_hardlink_path());
 
   const DeltaArchiveManifest_File& long_small_change =
       archive->files(encoding.children(1).index());
   EXPECT_EQ(0, long_small_change.children_size());
   EXPECT_TRUE(S_ISREG(long_small_change.mode()));
   EXPECT_EQ(0, long_small_change.uid());
   EXPECT_EQ(0, long_small_change.gid());
   EXPECT_TRUE(long_small_change.has_data_format());
-  EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_BSDIFF,
-            long_small_change.data_format());
+  DeltaArchiveManifest_File_DataFormat expected_format =
+      DeltaArchiveManifest_File_DataFormat_BSDIFF;
+  if (test_diff_exclusion)
+    expected_format = DeltaArchiveManifest_File_DataFormat_FULL;
+  EXPECT_EQ(expected_format, long_small_change.data_format());
   EXPECT_TRUE(long_small_change.has_data_offset());
   EXPECT_TRUE(long_small_change.has_data_length());
   EXPECT_FALSE(long_small_change.has_hardlink_path());
 
   const DeltaArchiveManifest_File& nochange =
       archive->files(encoding.children(2).index());
   EXPECT_EQ(0, nochange.children_size());
   EXPECT_TRUE(S_ISREG(nochange.mode()));
   EXPECT_EQ(0, nochange.uid());
   EXPECT_EQ(0, nochange.gid());
-  EXPECT_TRUE(nochange.has_data_format());
-  EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, nochange.data_format());
-  EXPECT_TRUE(nochange.has_data_offset());
-  EXPECT_TRUE(nochange.has_data_length());
+  EXPECT_FALSE(nochange.has_data_format());
+  EXPECT_FALSE(nochange.has_data_offset());
+  EXPECT_FALSE(nochange.has_data_length());
   EXPECT_FALSE(nochange.has_hardlink_path());
 
   const DeltaArchiveManifest_File& onebyte =
       archive->files(encoding.children(3).index());
   EXPECT_EQ(0, onebyte.children_size());
   EXPECT_TRUE(S_ISREG(onebyte.mode()));
   EXPECT_EQ(0, onebyte.uid());
   EXPECT_EQ(0, onebyte.gid());
   EXPECT_TRUE(onebyte.has_data_format());
   EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, onebyte.data_format());
@@ skipping 54 matching lines @@
   ASSERT_TRUE(hello.has_data_length());
   EXPECT_GT(hello.data_length(), 0);
   EXPECT_FALSE(hello.has_hardlink_path());
 
   const DeltaArchiveManifest_File& newempty =
       archive->files(dir.children(3).index());
   EXPECT_EQ(0, newempty.children_size());
   EXPECT_TRUE(S_ISREG(newempty.mode()));
   EXPECT_EQ(0, newempty.uid());
   EXPECT_EQ(0, newempty.gid());
-  EXPECT_FALSE(newempty.has_data_format());
-  EXPECT_FALSE(newempty.has_data_offset());
-  EXPECT_FALSE(newempty.has_data_length());
+  EXPECT_TRUE(newempty.has_data_format());
+  EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, newempty.data_format());
+  EXPECT_TRUE(newempty.has_data_offset());
+  EXPECT_TRUE(newempty.has_data_length());
   EXPECT_FALSE(newempty.has_hardlink_path());
 
   const DeltaArchiveManifest_File& subdir =
       archive->files(dir.children(4).index());
   EXPECT_EQ(2, subdir.children_size());
   EXPECT_EQ("fifo", subdir.children(0).name());
   EXPECT_EQ("link", subdir.children(1).name());
   EXPECT_TRUE(S_ISDIR(subdir.mode()));
   EXPECT_EQ(0, subdir.uid());
   EXPECT_EQ(0, subdir.gid());
@@ skipping 78 matching lines @@
   DeltaArchiveManifest* archive =
       DeltaDiffGenerator::EncodeMetadataToProtoBuffer(
           (string(cwd) + "/diff-gen-test/new").c_str());
   EXPECT_TRUE(NULL != archive);
 
   EXPECT_TRUE(DeltaDiffGenerator::EncodeDataToDeltaFile(
       archive,
       string(cwd) + "/diff-gen-test/old",
       string(cwd) + "/diff-gen-test/new",
       string(cwd) + "/diff-gen-test/out.dat",
-      ""));
+      set<string>(), ""));
   // parse the file
 
   DeltaDiffParser parser(string(cwd) + "/diff-gen-test/out.dat");
   ASSERT_TRUE(parser.valid());
   DeltaDiffParser::Iterator it = parser.Begin();
   string expected_paths[] = {
     "",
     "/cdev",
     "/compress_link",
     "/dir",
@@ skipping 101 matching lines @@
   EXPECT_TRUE(file.has_data_format());
   EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, file.data_format());
   EXPECT_EQ("hello\n", ReadFilePartToString(string(cwd) +
                                             "/diff-gen-test/out.dat",
                                             file.data_offset(),
                                             file.data_length()));
 
   // newempty
   file = parser.GetFileAtPath("/dir/newempty");
   EXPECT_TRUE(S_ISREG(file.mode()));
-  EXPECT_FALSE(file.has_data_format());
+  EXPECT_TRUE(file.has_data_format());
+  EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, file.data_format());
 
   // subdir
   file = parser.GetFileAtPath("/dir/subdir");
   EXPECT_TRUE(S_ISDIR(file.mode()));
   EXPECT_FALSE(file.has_data_format());
 
   // fifo
   file = parser.GetFileAtPath("/dir/subdir/fifo");
   EXPECT_TRUE(S_ISFIFO(file.mode()));
   EXPECT_FALSE(file.has_data_format());
@@ skipping 35 matching lines @@
   data = ReadFilePart(string(cwd) + "/diff-gen-test/out.dat",
                       file.data_offset(), file.data_length());
   WriteFileVector(string(cwd) + "/diff-gen-test/patch", data);
   int rc = 1;
   vector<string> cmd;
   cmd.push_back("/usr/bin/bspatch");
   cmd.push_back(string(cwd) + "/diff-gen-test/old/encoding/long_small_change");
   cmd.push_back(string(cwd) + "/diff-gen-test/patch_result");
   cmd.push_back(string(cwd) + "/diff-gen-test/patch");
   Subprocess::SynchronousExec(cmd, &rc);
-  EXPECT_EQ(0, rc);
+  ASSERT_EQ(0, rc);
   vector<char> patch_result;
   EXPECT_TRUE(utils::ReadFile(string(cwd) + "/diff-gen-test/patch_result",
                               &patch_result));
   vector<char> expected_data(sizeof(kRandomString) + 1);
   memcpy(&expected_data[0], kRandomString, sizeof(kRandomString));
   expected_data[expected_data.size() - 1] = 'h';
   ExpectVectorsEq(expected_data, patch_result);
 
   // nochange
   file = parser.GetFileAtPath("/encoding/nochange");
   EXPECT_TRUE(S_ISREG(file.mode()));
-  EXPECT_TRUE(file.has_data_format());
-  EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, file.data_format());
-  EXPECT_EQ("nochange\n", ReadFilePartToString(string(cwd) +
-                                               "/diff-gen-test/out.dat",
-                                               file.data_offset(),
-                                               file.data_length()));
+  EXPECT_FALSE(file.has_data_format());
+  EXPECT_FALSE(file.has_data_offset());
+  EXPECT_FALSE(file.has_data_length());
 
   // onebyte
   file = parser.GetFileAtPath("/encoding/onebyte");
   EXPECT_TRUE(S_ISREG(file.mode()));
   EXPECT_TRUE(file.has_data_format());
   EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, file.data_format());
   EXPECT_EQ("h", ReadFilePartToString(string(cwd) +
                                       "/diff-gen-test/out.dat",
                                       file.data_offset(),
                                       file.data_length()));
@@ skipping 46 matching lines @@
   {
     vector<char> data(14);
     memcpy(&data[0], "CrAU\0\0\0\0\0\0\0\x0cxx", 12);
     WriteFileVector("diff-gen-test/baddelta", data);
     DeltaDiffParser parser("diff-gen-test/baddelta");
     EXPECT_FALSE(parser.valid());
   }
 }
 
 }  // namespace chromeos_update_engine