Switch to standard integer types in components/, part 3 of 4.

components/safe_browsing_db/prefix_set_unittest.cc

 // Copyright (c) 2012 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 "components/safe_browsing_db/prefix_set.h"
 
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "build/build_config.h"
 #include "components/safe_browsing_db/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace safe_browsing {
 
 namespace {
 
 const SBPrefix kHighBitClear = 1000u * 1000u * 1000u;
 const SBPrefix kHighBitSet = 3u * 1000u * 1000u * 1000u;
 
 }  // namespace
 
 class PrefixSetTest : public PlatformTest {
  protected:
   // Constants for the v1 format.
-  static const size_t kMagicOffset = 0 * sizeof(uint32);
-  static const size_t kVersionOffset = 1 * sizeof(uint32);
-  static const size_t kIndexSizeOffset = 2 * sizeof(uint32);
-  static const size_t kDeltasSizeOffset = 3 * sizeof(uint32);
-  static const size_t kFullHashesSizeOffset = 4 * sizeof(uint32);
-  static const size_t kPayloadOffset = 5 * sizeof(uint32);
+  static const size_t kMagicOffset = 0 * sizeof(uint32_t);
+  static const size_t kVersionOffset = 1 * sizeof(uint32_t);
+  static const size_t kIndexSizeOffset = 2 * sizeof(uint32_t);
+  static const size_t kDeltasSizeOffset = 3 * sizeof(uint32_t);
+  static const size_t kFullHashesSizeOffset = 4 * sizeof(uint32_t);
+  static const size_t kPayloadOffset = 5 * sizeof(uint32_t);
 
   // Generate a set of random prefixes to share between tests.  For
   // most tests this generation was a large fraction of the test time.
   //
   // The set should contain sparse areas where adjacent items are more
   // than 2^16 apart, and dense areas where adjacent items are less
   // than 2^16 apart.
   static void SetUpTestCase() {
     // Distribute clusters of prefixes.
     for (size_t i = 0; i < 250; ++i) {
       // Unsigned for overflow characteristics.
-      const uint32 base = static_cast<uint32>(base::RandUint64());
+      const uint32_t base = static_cast<uint32_t>(base::RandUint64());
       for (size_t j = 0; j < 10; ++j) {
-        const uint32 delta = static_cast<uint32>(base::RandUint64() & 0xFFFF);
+        const uint32_t delta =
+            static_cast<uint32_t>(base::RandUint64() & 0xFFFF);
         const SBPrefix prefix = static_cast<SBPrefix>(base + delta);
         shared_prefixes_.push_back(prefix);
       }
     }
 
     // Lay down a sparsely-distributed layer.
     const size_t count = shared_prefixes_.size();
     for (size_t i = 0; i < count; ++i) {
       const SBPrefix prefix = static_cast<SBPrefix>(base::RandUint64());
       shared_prefixes_.push_back(prefix);
@@ skipping 39 matching lines @@
     base::FilePath filename = temp_dir_.path().AppendASCII("PrefixSetTest");
 
     PrefixSetBuilder builder(shared_prefixes_);
     if (!builder.GetPrefixSetNoHashes()->WriteFile(filename))
       return false;
 
     *filenamep = filename;
     return true;
   }
 
-  // Helper function to read the uint32 value at |offset|, increment it
+  // Helper function to read the uint32_t value at |offset|, increment it
   // by |inc|, and write it back in place.  |fp| should be opened in
   // r+ mode.
   static void IncrementIntAt(FILE* fp, long offset, int inc) {
-    uint32 value = 0;
+    uint32_t value = 0;
 
     ASSERT_NE(-1, fseek(fp, offset, SEEK_SET));
     ASSERT_EQ(1U, fread(&value, sizeof(value), 1, fp));
 
     value += inc;
 
     ASSERT_NE(-1, fseek(fp, offset, SEEK_SET));
     ASSERT_EQ(1U, fwrite(&value, sizeof(value), 1, fp));
   }
 
@@ skipping 20 matching lines @@
     ASSERT_EQ(digested_size, payload_size);
     ASSERT_EQ(static_cast<long>(digested_size), ftell(fp));
 
     base::MD5Digest new_digest;
     base::MD5Final(&new_digest, &context);
     ASSERT_NE(-1, fseek(fp, digested_size, SEEK_SET));
     ASSERT_EQ(1U, fwrite(&new_digest, sizeof(new_digest), 1, fp));
     ASSERT_EQ(file_size, ftell(fp));
   }
 
-  // Open |filename| and increment the uint32 at |offset| by |inc|.
+  // Open |filename| and increment the uint32_t at |offset| by |inc|.
   // Then re-generate the checksum to account for the new contents.
   void ModifyAndCleanChecksum(const base::FilePath& filename, long offset,
                               int inc) {
-    int64 size_64;
+    int64_t size_64;
     ASSERT_TRUE(base::GetFileSize(filename, &size_64));
 
     base::ScopedFILE file(base::OpenFile(filename, "r+b"));
     IncrementIntAt(file.get(), offset, inc);
     CleanChecksum(file.get());
     file.reset();
 
-    int64 new_size_64;
+    int64_t new_size_64;
     ASSERT_TRUE(base::GetFileSize(filename, &new_size_64));
     ASSERT_EQ(new_size_64, size_64);
   }
 
   base::FilePath TestFilePath() {
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     return path.AppendASCII("components")
         .AppendASCII("test")
         .AppendASCII("data")
@@ skipping 343 matching lines @@
   file.reset();
   scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test corruption in the digest itself.
 TEST_F(PrefixSetTest, CorruptionDigest) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
-  int64 size_64;
+  int64_t size_64;
   ASSERT_TRUE(base::GetFileSize(filename, &size_64));
   base::ScopedFILE file(base::OpenFile(filename, "r+b"));
   long digest_offset = static_cast<long>(size_64 - sizeof(base::MD5Digest));
   ASSERT_NO_FATAL_FAILURE(IncrementIntAt(file.get(), digest_offset, 1));
   file.reset();
   scoped_ptr<const PrefixSet> prefix_set = PrefixSet::LoadFile(filename);
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test excess data after the digest (fails the size test).
@@ skipping 12 matching lines @@
 
 // Test that files which had 64-bit size_t are discarded.
 TEST_F(PrefixSetTest, SizeTRecovery) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   // Open the file for rewrite.
   base::ScopedFILE file(base::OpenFile(filename, "r+b"));
 
   // Leave existing magic and version.
-  ASSERT_NE(-1, fseek(file.get(), sizeof(uint32) * 2, SEEK_SET));
+  ASSERT_NE(-1, fseek(file.get(), sizeof(uint32_t) * 2, SEEK_SET));
 
   // Indicate two index values and two deltas.
-  uint32 val = 2;
+  uint32_t val = 2;
   ASSERT_EQ(sizeof(val), fwrite(&val, 1, sizeof(val), file.get()));
   ASSERT_EQ(sizeof(val), fwrite(&val, 1, sizeof(val), file.get()));
 
   // Write two index values with 64-bit "size_t".
-  std::pair<SBPrefix, uint64> item;
+  std::pair<SBPrefix, uint64_t> item;
   memset(&item, 0, sizeof(item));  // Includes any padding.
   item.first = 17;
   item.second = 0;
   ASSERT_EQ(sizeof(item), fwrite(&item, 1, sizeof(item), file.get()));
   item.first = 100042;
   item.second = 1;
   ASSERT_EQ(sizeof(item), fwrite(&item, 1, sizeof(item), file.get()));
 
   // Write two delta values.
-  uint16 delta = 23;
+  uint16_t delta = 23;
   ASSERT_EQ(sizeof(delta), fwrite(&delta, 1, sizeof(delta), file.get()));
   ASSERT_EQ(sizeof(delta), fwrite(&delta, 1, sizeof(delta), file.get()));
 
   // Leave space for the digest at the end, and regenerate it.
   base::MD5Digest dummy = { { 0 } };
   ASSERT_EQ(sizeof(dummy), fwrite(&dummy, 1, sizeof(dummy), file.get()));
   ASSERT_TRUE(base::TruncateFile(file.get()));
   CleanChecksum(file.get());
   file.reset();  // Flush updates.
 
@@ skipping 39 matching lines @@
 
 // Test that a version 1 file is discarded on read.
 TEST_F(PrefixSetTest, ReadSigned) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   // Open the file for rewrite.
   base::ScopedFILE file(base::OpenFile(filename, "r+b"));
 
   // Leave existing magic.
-  ASSERT_NE(-1, fseek(file.get(), sizeof(uint32), SEEK_SET));
+  ASSERT_NE(-1, fseek(file.get(), sizeof(uint32_t), SEEK_SET));
 
   // Version 1.
-  uint32 version = 1;
+  uint32_t version = 1;
   ASSERT_EQ(sizeof(version), fwrite(&version, 1, sizeof(version), file.get()));
 
   // Indicate two index values and two deltas.
-  uint32 val = 2;
+  uint32_t val = 2;
   ASSERT_EQ(sizeof(val), fwrite(&val, 1, sizeof(val), file.get()));
   ASSERT_EQ(sizeof(val), fwrite(&val, 1, sizeof(val), file.get()));
 
-  std::pair<int32, uint32> item;
+  std::pair<int32_t, uint32_t> item;
   memset(&item, 0, sizeof(item));  // Includes any padding.
   item.first = -1000;
   item.second = 0;
   ASSERT_EQ(sizeof(item), fwrite(&item, 1, sizeof(item), file.get()));
   item.first = 1000;
   item.second = 1;
   ASSERT_EQ(sizeof(item), fwrite(&item, 1, sizeof(item), file.get()));
 
   // Write two delta values.
-  uint16 delta = 23;
+  uint16_t delta = 23;
   ASSERT_EQ(sizeof(delta), fwrite(&delta, 1, sizeof(delta), file.get()));
   ASSERT_EQ(sizeof(delta), fwrite(&delta, 1, sizeof(delta), file.get()));
 
   // Leave space for the digest at the end, and regenerate it.
   base::MD5Digest dummy = { { 0 } };
   ASSERT_EQ(sizeof(dummy), fwrite(&dummy, 1, sizeof(dummy), file.get()));
   ASSERT_TRUE(base::TruncateFile(file.get()));
   CleanChecksum(file.get());
   file.reset();  // Flush updates.
 
@@ skipping 38 matching lines @@
   const SBFullHash kHash2 = SBFullHashForString("www.evil.com/phishing.html");
 
   EXPECT_TRUE(prefix_set->Exists(kHash1));
   EXPECT_TRUE(prefix_set->Exists(kHash2));
   EXPECT_FALSE(prefix_set->PrefixExists(kHash1.prefix));
   EXPECT_FALSE(prefix_set->PrefixExists(kHash2.prefix));
 }
 #endif
 
 }  // namespace safe_browsing