Switch to standard integer types in base/.

base/id_map_unittest.cc

 // Copyright (c) 2011 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 "base/id_map.h"
 
+#include <stdint.h>
+
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class TestObject {
 };
 
 class DestructorCounter {
  public:
   explicit DestructorCounter(int* counter) : counter_(counter) {}
   ~DestructorCounter() { ++(*counter_); }
 
  private:
   int* counter_;
 };
 
 TEST(IDMapTest, Basic) {
   IDMap<TestObject> map;
   EXPECT_TRUE(map.IsEmpty());
   EXPECT_EQ(0U, map.size());
 
   TestObject obj1;
   TestObject obj2;
 
-  int32 id1 = map.Add(&obj1);
+  int32_t id1 = map.Add(&obj1);
   EXPECT_FALSE(map.IsEmpty());
   EXPECT_EQ(1U, map.size());
   EXPECT_EQ(&obj1, map.Lookup(id1));
 
-  int32 id2 = map.Add(&obj2);
+  int32_t id2 = map.Add(&obj2);
   EXPECT_FALSE(map.IsEmpty());
   EXPECT_EQ(2U, map.size());
 
   EXPECT_EQ(&obj1, map.Lookup(id1));
   EXPECT_EQ(&obj2, map.Lookup(id2));
 
   map.Remove(id1);
   EXPECT_FALSE(map.IsEmpty());
   EXPECT_EQ(1U, map.size());
 
@@ skipping 48 matching lines @@
 TEST(IDMapTest, IteratorRemainsValidWhenRemovingOtherElements) {
   IDMap<TestObject> map;
 
   const int kCount = 5;
   TestObject obj[kCount];
 
   for (int i = 0; i < kCount; i++)
     map.Add(&obj[i]);
 
   // IDMap uses a hash_map, which has no predictable iteration order.
-  int32 ids_in_iteration_order[kCount];
+  int32_t ids_in_iteration_order[kCount];
   const TestObject* objs_in_iteration_order[kCount];
   int counter = 0;
   for (IDMap<TestObject>::const_iterator iter(&map);
        !iter.IsAtEnd(); iter.Advance()) {
     ids_in_iteration_order[counter] = iter.GetCurrentKey();
     objs_in_iteration_order[counter] = iter.GetCurrentValue();
     counter++;
   }
 
   counter = 0;
@@ skipping 89 matching lines @@
 TEST(IDMapTest, IteratorRemainsValidWhenClearing) {
   IDMap<TestObject> map;
 
   const int kCount = 5;
   TestObject obj[kCount];
 
   for (int i = 0; i < kCount; i++)
     map.Add(&obj[i]);
 
   // IDMap uses a hash_map, which has no predictable iteration order.
-  int32 ids_in_iteration_order[kCount];
+  int32_t ids_in_iteration_order[kCount];
   const TestObject* objs_in_iteration_order[kCount];
   int counter = 0;
   for (IDMap<TestObject>::const_iterator iter(&map);
        !iter.IsAtEnd(); iter.Advance()) {
     ids_in_iteration_order[counter] = iter.GetCurrentKey();
     objs_in_iteration_order[counter] = iter.GetCurrentValue();
     counter++;
   }
 
   counter = 0;
@@ skipping 135 matching lines @@
   const int64_t kId1 = 999999999999999999;
 
   map.AddWithID(&obj1, kId1);
   EXPECT_EQ(&obj1, map.Lookup(kId1));
 
   map.Remove(kId1);
   EXPECT_TRUE(map.IsEmpty());
 }
 
 }  // namespace