AU: Start checkpointing update progress.

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>
 
+#include <base/scoped_ptr.h>
+#include <base/string_util.h>
 #include <google/protobuf/repeated_field.h>
 #include <gtest/gtest.h>
 
-#include "base/scoped_ptr.h"
-#include "base/string_util.h"
 #include "update_engine/delta_diff_generator.h"
 #include "update_engine/delta_performer.h"
 #include "update_engine/graph_types.h"
 #include "update_engine/payload_signer.h"
+#include "update_engine/prefs_mock.h"
 #include "update_engine/test_utils.h"
 #include "update_engine/update_metadata.pb.h"
 #include "update_engine/utils.h"
 
 namespace chromeos_update_engine {
 
 using std::min;
 using std::string;
 using std::vector;
+using testing::_;
+using testing::Return;
 
 extern const char* kUnittestPrivateKeyPath;
 extern const char* kUnittestPublicKeyPath;
 
 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;
@@ skipping 158 matching lines @@
                                                     old_kernel,
                                                     new_kernel,
                                                     delta_path,
                                                     kUnittestPrivateKeyPath));
   }
 
   // Read delta into memory.
   vector<char> delta;
   EXPECT_TRUE(utils::ReadFile(delta_path, &delta));
 
+  uint64_t manifest_metadata_size;
+
   // Check that the null signature blob exists
   {
     LOG(INFO) << "delta size: " << delta.size();
     DeltaArchiveManifest manifest;
     const int kManifestSizeOffset = 12;
     const int kManifestOffset = 20;
     uint64_t manifest_size = 0;
     memcpy(&manifest_size, &delta[kManifestSizeOffset], sizeof(manifest_size));
     manifest_size = be64toh(manifest_size);
     LOG(INFO) << "manifest size: " << manifest_size;
     EXPECT_TRUE(manifest.ParseFromArray(&delta[kManifestOffset],
                                         manifest_size));
     EXPECT_TRUE(manifest.has_signatures_offset());
+    manifest_metadata_size = kManifestOffset + manifest_size;
 
     Signatures sigs_message;
     EXPECT_TRUE(sigs_message.ParseFromArray(
-        &delta[kManifestOffset + manifest_size + manifest.signatures_offset()],
+        &delta[manifest_metadata_size + manifest.signatures_offset()],
         manifest.signatures_size()));
     EXPECT_EQ(1, sigs_message.signatures_size());
     const Signatures_Signature& signature = sigs_message.signatures(0);
     EXPECT_EQ(1, signature.version());
 
     uint64_t expected_sig_data_length = 0;
     EXPECT_TRUE(PayloadSigner::SignatureBlobLength(kUnittestPrivateKeyPath,
                                                    &expected_sig_data_length));
     EXPECT_EQ(expected_sig_data_length, manifest.signatures_size());
     EXPECT_FALSE(signature.data().empty());
   }
 
+  PrefsMock prefs;
+  EXPECT_CALL(prefs, SetInt64(kPrefsManifestMetadataSize,
+                              manifest_metadata_size)).WillOnce(Return(true));
+  EXPECT_CALL(prefs, SetInt64(kPrefsUpdateStateNextOperation, _))
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(prefs, SetInt64(kPrefsUpdateStateNextDataOffset, _))
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(prefs, SetString(kPrefsUpdateStateSignedSHA256Context, _))
+      .WillRepeatedly(Return(true));
+
   // Update the A image in place.
-  DeltaPerformer performer;
+  DeltaPerformer performer(&prefs);
 
   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(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)));
 
   EXPECT_TRUE(utils::FileExists(kUnittestPublicKeyPath));
   EXPECT_TRUE(performer.VerifyPayload(kUnittestPublicKeyPath));
 }
 
 }  // namespace chromeos_update_engine