Readability review.

counter_test.cc

 // Copyright (c) 2010 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/file.h>
 
 #include <base/eintr_wrapper.h>
 #include <base/file_util.h>
 #include <base/logging.h>
 #include <base/string_util.h>
@@ skipping 44 matching lines @@
 
   virtual void TearDown() {
     logging::SetLogMessageHandler(NULL);
     test_ = NULL;
     file_util::Delete(FilePath(kTestRecordFile), false);
   }
 
   // Asserts that the record file contains the specified contents.
   testing::AssertionResult AssertRecord(const char* expr_tag,
                                         const char* expr_count,
-                                        int expected_tag,
-                                        int expected_count) {
+                                        int32 expected_tag,
+                                        int32 expected_count) {
     int fd = HANDLE_EINTR(open(kTestRecordFile, O_RDONLY));
     if (fd < 0) {
       testing::Message msg;
       msg << "Unable to open " << kTestRecordFile;
       return testing::AssertionFailure(msg);
     }
 
     TaggedCounter::Record record;
     if (!file_util::ReadFromFD(fd, reinterpret_cast<char*>(&record),
                                sizeof(record))) {
@@ skipping 21 matching lines @@
   bool AssertNoOrEmptyRecordFile() {
     FilePath record_file(counter_.filename_);
     int64 record_file_size;
     return !file_util::PathExists(record_file) ||
         (file_util::GetFileSize(record_file, &record_file_size) &&
          record_file_size == 0);
   }
 
   // Adds a reporter call expectation that the specified tag/count
   // callback will be generated.
-  void ExpectReporterCall(int tag, int count) {
+  void ExpectReporterCall(int32 tag, int32 count) {
     EXPECT_CALL(reporter_, Call(_, tag, count))
         .Times(1)
         .RetiresOnSaturation();
   }
 
   // The reporter callback forwards the call to the reporter mock so
   // that we can set call expectations.
-  static void Reporter(void* handle, int tag, int count) {
+  static void Reporter(void* handle, int32 tag, int32 count) {
     TaggedCounterTest* test = static_cast<TaggedCounterTest*>(handle);
     ASSERT_FALSE(NULL == test);
     test->reporter_.Call(handle, tag, count);
   }
 
   // Collects log messages in the |log_| member string so that they
   // can be analyzed for errors and expected behavior.
   static bool HandleLogMessages(int severity, const std::string& str) {
     test_->log_.append(str);
     test_->log_.append("\n");
 
     // Returning true would mute the log.
     return false;
   }
 
   // Returns true if the counter log contains |pattern|, false otherwise.
-  bool LogContains(const std::string& pattern) {
+  bool LogContains(const std::string& pattern) const {
     return log_.find(pattern) != std::string::npos;
   }
 
   // The TaggedCounter object under test.
   TaggedCounter counter_;
 
   // The accumulated counter log.
   std::string log_;
 
   // Reporter mock to set callback expectations on.
-  StrictMock<MockFunction<void(void* handle, int tag, int count)> > reporter_;
+  StrictMock<MockFunction<void(void* handle,
+                               int32 tag, int32 count)> > reporter_;
 
   // Pointer to the current test fixture.
   static TaggedCounterTest* test_;
 };
 
 // static
 TaggedCounterTest* TaggedCounterTest::test_ = NULL;
 
 TEST_F(RecordTest, Init) {
   record_.Init(/* tag */ 5, /* count */ -1);
@@ skipping 11 matching lines @@
 
   record_.Add(/* count */ 5);
   EXPECT_EQ(5, record_.count());
 
   record_.Add(/* count */ 10);
   EXPECT_EQ(15, record_.count());
 
   record_.Add(/* count */ -2);
   EXPECT_EQ(15, record_.count());
 
-  record_.Add(/* count */ INT_MAX);
-  EXPECT_EQ(INT_MAX, record_.count());
+  record_.Add(/* count */ kint32max);
+  EXPECT_EQ(kint32max, record_.count());
 
   record_.Add(/* count */ 1);
-  EXPECT_EQ(INT_MAX, record_.count());
+  EXPECT_EQ(kint32max, record_.count());
 }
 
 TEST_F(TaggedCounterTest, BadFileLocation) {
   // Checks that the counter doesn't die badly if the file can't be
   // created.
   counter_.Init(kDoesNotExistFile,
                 /* reporter */ NULL, /* reporter_handle */ NULL);
   counter_.Update(/* tag */ 10, /* count */ 20);
   EXPECT_TRUE(LogContains("Unable to open the persistent counter file: "
                           "No such file or directory"));
@@ skipping 62 matching lines @@
   EXPECT_TRUE(AssertNoOrEmptyRecordFile());
   EXPECT_EQ(TaggedCounter::kRecordNull, counter_.record_state_);
 }
 
 }  // namespace chromeos_metrics
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }