AU: Include the old/new kernel/rootfs size/hash in the update metadata.

omaha_hash_calculator_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 <math.h>
 #include <unistd.h>
 
+#include <string>
 #include <vector>
 
 #include <glib.h>
 #include <gtest/gtest.h>
 
 #include "update_engine/libcurl_http_fetcher.h"
 #include "update_engine/omaha_hash_calculator.h"
+#include "update_engine/utils.h"
 
+using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 class OmahaHashCalculatorTest : public ::testing::Test { };
 
 // Generated by running this on a linux shell:
 // $ echo -n hi | openssl dgst -sha256 -binary | openssl base64
 static const char kExpectedHash[] =
     "j0NDRmSPa5bfid2pAcUXaxCm2Dlh3TwayItZstwyeqQ=";
@@ skipping 21 matching lines @@
   calc.Finalize();
   EXPECT_EQ(kExpectedHash, calc.hash());
   vector<char> raw_hash(kExpectedRawHash,
                         kExpectedRawHash + arraysize(kExpectedRawHash));
   EXPECT_TRUE(raw_hash == calc.raw_hash());
 }
 
 TEST(OmahaHashCalculatorTest, ContextTest) {
   OmahaHashCalculator calc;
   calc.Update("h", 1);
+  string calc_context = calc.GetContext();
+  calc.Finalize();
   OmahaHashCalculator calc_next;
-  calc_next.SetContext(calc.GetContext());
+  calc_next.SetContext(calc_context);
   calc_next.Update("i", 1);
   calc_next.Finalize();
-  // Generated by running this on a linux shell:
-  // $ echo -n hi | openssl dgst -sha256 -binary | openssl base64
-  EXPECT_EQ("j0NDRmSPa5bfid2pAcUXaxCm2Dlh3TwayItZstwyeqQ=", calc_next.hash());
+  EXPECT_EQ(kExpectedHash, calc_next.hash());
+  vector<char> raw_hash(kExpectedRawHash,
+                        kExpectedRawHash + arraysize(kExpectedRawHash));
+  EXPECT_TRUE(raw_hash == calc_next.raw_hash());
 }
 
 TEST(OmahaHashCalculatorTest, BigTest) {
   OmahaHashCalculator calc;
 
   for (int i = 0; i < 1000000; i++) {
     char buf[8];
     ASSERT_EQ(0 == i ? 1 : static_cast<int>(floorf(logf(i) / logf(10))) + 1,
               snprintf(buf, sizeof(buf), "%d", i)) << " i = " << i;
     calc.Update(buf, strlen(buf));
   }
   calc.Finalize();
 
   // Hash constant generated by running this on a linux shell:
   // $ C=0
   // $ while [ $C -lt 1000000 ]; do
   //     echo -n $C
   //     let C=C+1
   //   done | openssl dgst -sha256 -binary | openssl base64
   EXPECT_EQ("NZf8k6SPBkYMvhaX8YgzuMgbkLP1XZ+neM8K5wcSsf8=", calc.hash());
 }
 
+TEST(OmahaHashCalculatorTest, UpdateFileSimpleTest) {
+  string data_path;
+  ASSERT_TRUE(
+      utils::MakeTempFile("/tmp/data.XXXXXX", &data_path, NULL));
+  ScopedPathUnlinker data_path_unlinker(data_path);
+  ASSERT_TRUE(utils::WriteFile(data_path.c_str(), "hi", 2));
+
+  static const int kLengths[] = { -1, 2, 10 };
+  for (size_t i = 0; i < arraysize(kLengths); i++) {
+    OmahaHashCalculator calc;
+    EXPECT_EQ(2, calc.UpdateFile(data_path, kLengths[i]));
+    EXPECT_TRUE(calc.Finalize());
+    EXPECT_EQ(kExpectedHash, calc.hash());
+    vector<char> raw_hash(kExpectedRawHash,
+                          kExpectedRawHash + arraysize(kExpectedRawHash));
+    EXPECT_TRUE(raw_hash == calc.raw_hash());
+  }
+
+  OmahaHashCalculator calc;
+  EXPECT_EQ(0, calc.UpdateFile(data_path, 0));
+  EXPECT_EQ(1, calc.UpdateFile(data_path, 1));
+  EXPECT_TRUE(calc.Finalize());
+  // echo -n h | openssl dgst -sha256 -binary | openssl base64
+  EXPECT_EQ("qqlAJmTxpB9A67xSyZk+tmrrNmYClY/fqig7ceZNsSM=", calc.hash());
+}
+
+TEST(OmahaHashCalculatorTest, UpdateFileNonexistentTest) {
+  OmahaHashCalculator calc;
+  EXPECT_EQ(-1, calc.UpdateFile("/some/non-existent/file", -1));
+}
+
 TEST(OmahaHashCalculatorTest, AbortTest) {
   // Just make sure we don't crash and valgrind doesn't detect memory leaks
   {
     OmahaHashCalculator calc;
   }
   {
     OmahaHashCalculator calc;
     calc.Update("h", 1);
   }
 }
 
 }  // namespace chromeos_update_engine