Switch to standard integer types in chrome/browser/, part 4 of 4.

chrome/browser/spellchecker/feedback_unittest.cc

 // Copyright (c) 2013 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.
 //
 // Unit tests for |Feedback| object.
 
 #include "chrome/browser/spellchecker/feedback.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 
 namespace spellcheck {
 
 namespace {
 
 // Maximum number of bytes of feedback that would be sent to the server at once.
 const size_t kMaxFeedbackSize = 1024;
 
 // Identifier for a renderer process.
 const int kRendererProcessId = 7;
 
 // Hash identifier for a misspelling.
-const uint32 kMisspellingHash = 42;
+const uint32_t kMisspellingHash = 42;
 
 }  // namespace
 
 // A test fixture to help keep the tests simple.
 class FeedbackTest : public testing::Test {
  public:
   FeedbackTest() : feedback_(kMaxFeedbackSize) {}
   ~FeedbackTest() override {}
 
  protected:
-  void AddMisspelling(int renderer_process_id, uint32 hash) {
+  void AddMisspelling(int renderer_process_id, uint32_t hash) {
     feedback_.AddMisspelling(renderer_process_id,
                              Misspelling(base::string16(), 0, 0,
                                          std::vector<base::string16>(), hash));
   }
 
   spellcheck::Feedback feedback_;
 };
 
 TEST_F(FeedbackTest, LimitFeedbackSize) {
   // Adding too much feedback data should prevent adding more feedback.
@@ skipping 23 matching lines @@
   feedback_.Clear();
 
   // Erasing finalized misspellings should allow adding feedback again.
   feedback_.AddMisspelling(
       kRendererProcessId,
       Misspelling(
           base::ASCIIToUTF16("0123456789"), 0, 1,
           std::vector<base::string16>(50, base::ASCIIToUTF16("9876543210")),
           0));
   feedback_.FinalizeRemovedMisspellings(kRendererProcessId,
-                                        std::vector<uint32>());
+                                        std::vector<uint32_t>());
   feedback_.EraseFinalizedMisspellings(kRendererProcessId);
   feedback_.AddMisspelling(
       kRendererProcessId,
       Misspelling(
           base::ASCIIToUTF16("0123456789"), 0, 1,
           std::vector<base::string16>(50, base::ASCIIToUTF16("9876543210")),
           kMisspellingHash));
   EXPECT_NE(nullptr, feedback_.GetMisspelling(kMisspellingHash));
 }
 
 // Should be able to retrieve misspelling after it's added.
 TEST_F(FeedbackTest, RetreiveMisspelling) {
   EXPECT_EQ(nullptr, feedback_.GetMisspelling(kMisspellingHash));
   AddMisspelling(kRendererProcessId, kMisspellingHash);
   Misspelling* result = feedback_.GetMisspelling(kMisspellingHash);
   EXPECT_NE(nullptr, result);
   EXPECT_EQ(kMisspellingHash, result->hash);
 }
 
 // Removed misspellings should be finalized.
 TEST_F(FeedbackTest, FinalizeRemovedMisspellings) {
   static const int kRemovedMisspellingHash = 1;
   static const int kRemainingMisspellingHash = 2;
   AddMisspelling(kRendererProcessId, kRemovedMisspellingHash);
   AddMisspelling(kRendererProcessId, kRemainingMisspellingHash);
-  std::vector<uint32> remaining_markers(1, kRemainingMisspellingHash);
+  std::vector<uint32_t> remaining_markers(1, kRemainingMisspellingHash);
   feedback_.FinalizeRemovedMisspellings(kRendererProcessId, remaining_markers);
   Misspelling* removed_misspelling =
       feedback_.GetMisspelling(kRemovedMisspellingHash);
   EXPECT_NE(nullptr, removed_misspelling);
   EXPECT_TRUE(removed_misspelling->action.IsFinal());
   Misspelling* remaining_misspelling =
       feedback_.GetMisspelling(kRemainingMisspellingHash);
   EXPECT_NE(nullptr, remaining_misspelling);
   EXPECT_FALSE(remaining_misspelling->action.IsFinal());
 }
 
 // Duplicate misspellings should not be finalized.
 TEST_F(FeedbackTest, DuplicateMisspellingFinalization) {
   AddMisspelling(kRendererProcessId, kMisspellingHash);
   AddMisspelling(kRendererProcessId, kMisspellingHash);
-  std::vector<uint32> remaining_markers(1, kMisspellingHash);
+  std::vector<uint32_t> remaining_markers(1, kMisspellingHash);
   feedback_.FinalizeRemovedMisspellings(kRendererProcessId, remaining_markers);
   std::vector<Misspelling> misspellings = feedback_.GetAllMisspellings();
   EXPECT_EQ(static_cast<size_t>(1), misspellings.size());
   EXPECT_FALSE(misspellings[0].action.IsFinal());
 }
 
 // Misspellings should be associated with a renderer.
 TEST_F(FeedbackTest, RendererHasMisspellings) {
   EXPECT_FALSE(feedback_.RendererHasMisspellings(kRendererProcessId));
   AddMisspelling(kRendererProcessId, kMisspellingHash);
   EXPECT_TRUE(feedback_.RendererHasMisspellings(kRendererProcessId));
 }
 
 // Should be able to retrieve misspellings in renderer.
 TEST_F(FeedbackTest, GetMisspellingsInRenderer) {
   AddMisspelling(kRendererProcessId, kMisspellingHash);
   const std::vector<Misspelling>& renderer_with_misspellings =
       feedback_.GetMisspellingsInRenderer(kRendererProcessId);
   EXPECT_EQ(static_cast<size_t>(1), renderer_with_misspellings.size());
   EXPECT_EQ(kMisspellingHash, renderer_with_misspellings[0].hash);
   const std::vector<Misspelling>& renderer_without_misspellings =
       feedback_.GetMisspellingsInRenderer(kRendererProcessId + 1);
   EXPECT_EQ(static_cast<size_t>(0), renderer_without_misspellings.size());
 }
 
 // Finalized misspellings should be erased.
 TEST_F(FeedbackTest, EraseFinalizedMisspellings) {
   AddMisspelling(kRendererProcessId, kMisspellingHash);
   feedback_.FinalizeRemovedMisspellings(kRendererProcessId,
-                                        std::vector<uint32>());
+                                        std::vector<uint32_t>());
   EXPECT_TRUE(feedback_.RendererHasMisspellings(kRendererProcessId));
   feedback_.EraseFinalizedMisspellings(kRendererProcessId);
   EXPECT_FALSE(feedback_.RendererHasMisspellings(kRendererProcessId));
   EXPECT_TRUE(feedback_.GetMisspellingsInRenderer(kRendererProcessId).empty());
 }
 
 // Should be able to check for misspelling existence.
 TEST_F(FeedbackTest, HasMisspelling) {
   EXPECT_FALSE(feedback_.HasMisspelling(kMisspellingHash));
   AddMisspelling(kRendererProcessId, kMisspellingHash);
@@ skipping 68 matching lines @@
 // Should be able to find misspellings by misspelled word.
 TEST_F(FeedbackTest, FindMisspellingsByText) {
   static const base::string16 kMisspelledText =
       ASCIIToUTF16("Helllo world. Helllo world");
   static const base::string16 kSuggestion = ASCIIToUTF16("Hello");
   static const int kMisspellingStart = 0;
   static const int kMisspellingLength = 6;
   static const int kSentenceLength = 14;
   static const int kNumberOfSentences = 2;
   static const int kNumberOfRenderers = 2;
-  uint32 hash = kMisspellingHash;
+  uint32_t hash = kMisspellingHash;
   for (int renderer_process_id = kRendererProcessId;
        renderer_process_id < kRendererProcessId + kNumberOfRenderers;
        ++renderer_process_id) {
     for (int j = 0; j < kNumberOfSentences; ++j) {
       feedback_.AddMisspelling(
           renderer_process_id,
           Misspelling(kMisspelledText, kMisspellingStart + j * kSentenceLength,
                       kMisspellingLength,
                       std::vector<base::string16>(1, kSuggestion), ++hash));
     }
   }
 
   static const base::string16 kOtherMisspelledText =
       ASCIIToUTF16("Somethign else");
   static const base::string16 kOtherSuggestion = ASCIIToUTF16("Something");
   static const int kOtherMisspellingStart = 0;
   static const int kOtherMisspellingLength = 9;
   feedback_.AddMisspelling(
       kRendererProcessId,
       Misspelling(kOtherMisspelledText, kOtherMisspellingStart,
                   kOtherMisspellingLength,
                   std::vector<base::string16>(1, kOtherSuggestion), hash + 1));
 
   static const base::string16 kMisspelledWord = ASCIIToUTF16("Helllo");
-  const std::set<uint32>& misspellings =
+  const std::set<uint32_t>& misspellings =
       feedback_.FindMisspellings(kMisspelledWord);
   EXPECT_EQ(static_cast<size_t>(kNumberOfSentences * kNumberOfRenderers),
             misspellings.size());
 
-  for (std::set<uint32>::const_iterator it = misspellings.begin();
+  for (std::set<uint32_t>::const_iterator it = misspellings.begin();
        it != misspellings.end(); ++it) {
     Misspelling* misspelling = feedback_.GetMisspelling(*it);
     EXPECT_NE(nullptr, misspelling);
     EXPECT_TRUE(misspelling->hash >= kMisspellingHash &&
                 misspelling->hash <= hash);
     EXPECT_EQ(kMisspelledWord, GetMisspelledString(*misspelling));
   }
 }
 
 // Should not be able to find misspellings by misspelled word after they have
 // been removed.
 TEST_F(FeedbackTest, CannotFindMisspellingsByTextAfterErased) {
   static const base::string16 kMisspelledText = ASCIIToUTF16("Helllo world");
   static const base::string16 kMisspelledWord = ASCIIToUTF16("Helllo");
   static const base::string16 kSuggestion = ASCIIToUTF16("Hello");
   static const int kMisspellingStart = 0;
   static const int kMisspellingLength = 6;
   feedback_.AddMisspelling(
       kRendererProcessId,
       Misspelling(kMisspelledText, kMisspellingStart, kMisspellingLength,
                   std::vector<base::string16>(1, kSuggestion),
                   kMisspellingHash));
   feedback_.GetMisspelling(kMisspellingHash)->action.Finalize();
   feedback_.EraseFinalizedMisspellings(kRendererProcessId);
   EXPECT_TRUE(feedback_.FindMisspellings(kMisspelledWord).empty());
 }
 
 }  // namespace spellcheck