AU: support for generating new style full updates.

delta_performer_unittest.cc

 // Copyright (c) 2009 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 <sys/mount.h>
 #include <inttypes.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
@@ skipping 16 matching lines @@
 
 using std::min;
 using std::string;
 using std::vector;
 using testing::_;
 using testing::Return;
 
 extern const char* kUnittestPrivateKeyPath;
 extern const char* kUnittestPublicKeyPath;
 
+namespace {
+  const size_t kBlockSize = 4096;
+}  // namespace {}
+
+
 class DeltaPerformerTest : public ::testing::Test { };
 
 TEST(DeltaPerformerTest, ExtentsToByteStringTest) {
   uint64_t test[] = {1, 1, 4, 2, kSparseHole, 1, 0, 1};
   COMPILE_ASSERT(arraysize(test) % 2 == 0, array_size_uneven);
   const uint64_t block_size = 4096;
   const uint64_t file_length = 5 * block_size - 13;
 
   google::protobuf::RepeatedPtrField<Extent> extents;
   for (size_t i = 0; i < arraysize(test); i += 2) {
@@ skipping 31 matching lines @@
   scoped_ptr<ScopedLoopbackDeviceReleaser> loop_releaser_;
   scoped_ptr<ScopedFilesystemUnmounter> unmounter_;
 };
 
 void CompareFilesByBlock(const string& a_file, const string& b_file) {
   vector<char> a_data, b_data;
   EXPECT_TRUE(utils::ReadFile(a_file, &a_data)) << "file failed: " << a_file;
   EXPECT_TRUE(utils::ReadFile(b_file, &b_data)) << "file failed: " << b_file;
 
   EXPECT_EQ(a_data.size(), b_data.size());
-  size_t kBlockSize = 4096;
   EXPECT_EQ(0, a_data.size() % kBlockSize);
   for (size_t i = 0; i < a_data.size(); i += kBlockSize) {
     EXPECT_EQ(0, i % kBlockSize);
     vector<char> a_sub(&a_data[i], &a_data[i + kBlockSize]);
     vector<char> b_sub(&b_data[i], &b_data[i + kBlockSize]);
     EXPECT_TRUE(a_sub == b_sub) << "Block " << (i/kBlockSize) << " differs";
   }
 }
 
 namespace {
@@ skipping 171 matching lines @@
 
   vector<char> updated_kernel_partition;
   EXPECT_TRUE(utils::ReadFile(old_kernel, &updated_kernel_partition));
   EXPECT_EQ(0, strncmp(&updated_kernel_partition[0], new_data_string,
                        strlen(new_data_string)));
 
   EXPECT_TRUE(utils::FileExists(kUnittestPublicKeyPath));
   EXPECT_TRUE(performer.VerifyPayload(kUnittestPublicKeyPath));
 }
 
+TEST(DeltaPerformerTest, NewFullUpdateTest) {
+  vector<char> new_root(20 * 1024 * 1024);
+  vector<char> new_kern(16 * 1024 * 1024);
+  const off_t kChunkSize = 128 * 1024;
+  FillWithData(&new_root);
+  FillWithData(&new_kern);
+  
+  string new_root_path;
+  EXPECT_TRUE(utils::MakeTempFile("/tmp/NewFullUpdateTest_R.XXXXXX",
+                                  &new_root_path,
+                                  NULL));
+  ScopedPathUnlinker new_root_path_unlinker(new_root_path);
+  EXPECT_TRUE(WriteFileVector(new_root_path, new_root));
+
+  string new_kern_path;
+  EXPECT_TRUE(utils::MakeTempFile("/tmp/NewFullUpdateTest_K.XXXXXX",
+                                  &new_kern_path,
+                                  NULL));
+  ScopedPathUnlinker new_kern_path_unlinker(new_kern_path);
+  EXPECT_TRUE(WriteFileVector(new_kern_path, new_kern));
+
+  string out_blobs_path;
+  int out_blobs_fd;
+  EXPECT_TRUE(utils::MakeTempFile("/tmp/NewFullUpdateTest_D.XXXXXX",
+                                  &out_blobs_path,
+                                  &out_blobs_fd));
+  ScopedPathUnlinker out_blobs_path_unlinker(out_blobs_path);
+  ScopedFdCloser out_blobs_fd_closer(&out_blobs_fd);
+  
+  off_t out_blobs_length = 0;
+  
+  Graph graph;
+  vector<DeltaArchiveManifest_InstallOperation> kernel_ops;
+  vector<Vertex::Index> final_order;
+  
+  EXPECT_TRUE(DeltaDiffGenerator::ReadFullUpdateFromDisk(&graph,
+                                                         new_kern_path,
+                                                         new_root_path,
+                                                         out_blobs_fd,
+                                                         &out_blobs_length,
+                                                         kChunkSize,
+                                                         &kernel_ops,
+                                                         &final_order));
+  EXPECT_EQ(new_root.size() / kChunkSize, graph.size());
+  EXPECT_EQ(new_root.size() / kChunkSize, final_order.size());
+  EXPECT_EQ(new_kern.size() / kChunkSize, kernel_ops.size());
+  for (size_t i = 0; i < (new_root.size() / kChunkSize); ++i) {
+    EXPECT_EQ(i, final_order[i]);
+    EXPECT_EQ(1, graph[i].op.dst_extents_size());
+    EXPECT_EQ(i * kChunkSize / kBlockSize,
+              graph[i].op.dst_extents(0).start_block()) << "i = " << i;
+    EXPECT_EQ(kChunkSize / kBlockSize,
+              graph[i].op.dst_extents(0).num_blocks());
+    if (graph[i].op.type() !=
+        DeltaArchiveManifest_InstallOperation_Type_REPLACE) {
+      EXPECT_EQ(DeltaArchiveManifest_InstallOperation_Type_REPLACE_BZ,
+                graph[i].op.type());
+    }
+  }
+}
+
 }  // namespace chromeos_update_engine