AU: delta compress the kernel partition

src/platform/update_engine/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 136 matching lines @@
                                 1024 * 1024));
     EXPECT_EQ(0, system(StringPrintf("dd if=/dev/zero of=%s/partsparese bs=1 "
                                      "seek=4096 count=1",
                                      b_mnt.c_str()).c_str()));
     EXPECT_TRUE(utils::WriteFile(StringPrintf("%s/hardtocompress",
                                               b_mnt.c_str()).c_str(),
                                  reinterpret_cast<const char*>(kRandomString),
                                  sizeof(kRandomString)));
   }
 
+  string old_kernel;
+  EXPECT_TRUE(utils::MakeTempFile("/tmp/old_kernel.XXXXXX", &old_kernel, NULL));
+  ScopedPathUnlinker old_kernel_unlinker(old_kernel);
+
+  string new_kernel;
+  EXPECT_TRUE(utils::MakeTempFile("/tmp/new_kernel.XXXXXX", &new_kernel, NULL));
+  ScopedPathUnlinker new_kernel_unlinker(new_kernel);
+
+  vector<char> old_kernel_data(4096);  // Something small for a test
+  vector<char> new_kernel_data(old_kernel_data.size());
+  FillWithData(&old_kernel_data);
+  FillWithData(&new_kernel_data);
+  
+  // change the new kernel data
+  const char* new_data_string = "This is new data.";
+  strcpy(&new_kernel_data[0], new_data_string);
+
+  // Write kernels to disk
+  EXPECT_TRUE(utils::WriteFile(
+      old_kernel.c_str(), &old_kernel_data[0], old_kernel_data.size()));
+  EXPECT_TRUE(utils::WriteFile(
+      new_kernel.c_str(), &new_kernel_data[0], new_kernel_data.size()));
+
   string delta_path;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/delta.XXXXXX", &delta_path, NULL));
   ScopedPathUnlinker delta_path_unlinker(delta_path);
   {
     string a_mnt, b_mnt;
     ScopedLoopMounter a_mounter(a_img, &a_mnt, MS_RDONLY);
     ScopedLoopMounter b_mounter(b_img, &b_mnt, MS_RDONLY);
 
     EXPECT_TRUE(DeltaDiffGenerator::GenerateDeltaUpdateFile(a_mnt,
                                                             a_img,
                                                             b_mnt,
                                                             b_img,
+                                                            old_kernel,
+                                                            new_kernel,
                                                             delta_path));
   }
 
   // Read delta into memory.
   vector<char> delta;
   EXPECT_TRUE(utils::ReadFile(delta_path, &delta));
 
   // Update the A image in place.
   DeltaPerformer performer;
 
   EXPECT_EQ(0, performer.Open(a_img.c_str(), 0, 0));
+  EXPECT_TRUE(performer.OpenKernel(old_kernel.c_str()));
 
   // Write at some number of bytes per operation. Arbitrarily chose 5.
   const size_t kBytesPerWrite = 5;
   for (size_t i = 0; i < delta.size(); i += kBytesPerWrite) {
     size_t count = min(delta.size() - i, kBytesPerWrite);
     EXPECT_EQ(count, performer.Write(&delta[i], count));
   }
 
   // Wrapper around close. Returns 0 on success or -errno on error.
   EXPECT_EQ(0, performer.Close());
 
   CompareFilesByBlock("/tmp/a_ref", "/tmp/b_ref");
+  CompareFilesByBlock(old_kernel, new_kernel);
+  
+  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)));
 }
 
 }  // namespace chromeos_update_engine