Remove kint64min.

sync/internal_api/public/base/unique_position_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 "sync/internal_api/public/base/unique_position.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 #include <string>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "sync/protocol/unique_position.pb.h"
@@ skipping 374 matching lines @@
     // suffix format is a base64'ed SHA1 hash, which should be fairly close to
     // random anyway.
     std::string input = cache_guid_ + base::Int64ToString(next_id_--);
     std::string output;
     base::Base64Encode(base::SHA1HashString(input), &output);
     return output;
   }
 
  private:
   const std::string cache_guid_;
-  int64 next_id_;
+  int64_t next_id_;
 };
 
 // Cache guids generated in the same style as real clients.
 static const char kCacheGuidStr1[] = "tuiWdG8hV+8y4RT9N5Aikg==";
 static const char kCacheGuidStr2[] = "yaKb7zHtY06aue9a0vlZgw==";
 
 class PositionScenariosTest : public UniquePositionTest {
  public:
   PositionScenariosTest()
       : generator1_(std::string(kCacheGuidStr1, arraysize(kCacheGuidStr1)-1)),
@@ skipping 82 matching lines @@
 INSTANTIATE_TEST_CASE_P(NormalSuffix, PositionInsertTest,
                         ::testing::Values(kNormalSuffix));
 
 class PositionFromIntTest : public UniquePositionTest {
  public:
   PositionFromIntTest()
       : generator_(std::string(kCacheGuidStr1, arraysize(kCacheGuidStr1)-1)) {
   }
 
  protected:
-  static const int64 kTestValues[];
+  static const int64_t kTestValues[];
   static const size_t kNumTestValues;
 
   std::string NextSuffix() {
     return generator_.NextSuffix();
   }
 
  private:
   SuffixGenerator generator_;
 };
 
-const int64 PositionFromIntTest::kTestValues[] = {
-  0LL,
-  1LL, -1LL,
-  2LL, -2LL,
-  3LL, -3LL,
-  0x79LL, -0x79LL,
-  0x80LL, -0x80LL,
-  0x81LL, -0x81LL,
-  0xFELL, -0xFELL,
-  0xFFLL, -0xFFLL,
-  0x100LL, -0x100LL,
-  0x101LL, -0x101LL,
-  0xFA1AFELL, -0xFA1AFELL,
-  0xFFFFFFFELL, -0xFFFFFFFELL,
-  0xFFFFFFFFLL, -0xFFFFFFFFLL,
-  0x100000000LL, -0x100000000LL,
-  0x100000001LL, -0x100000001LL,
-  0xFFFFFFFFFFLL, -0xFFFFFFFFFFLL,
-  0x112358132134LL, -0x112358132134LL,
-  0xFEFFBEEFABC1234LL, -0xFEFFBEEFABC1234LL,
-  kint64max,
-  kint64min,
-  kint64min + 1,
-  kint64max - 1
-};
+const int64_t PositionFromIntTest::kTestValues[] = {0LL,
+                                                    1LL,
+                                                    -1LL,
+                                                    2LL,
+                                                    -2LL,
+                                                    3LL,
+                                                    -3LL,
+                                                    0x79LL,
+                                                    -0x79LL,
+                                                    0x80LL,
+                                                    -0x80LL,
+                                                    0x81LL,
+                                                    -0x81LL,
+                                                    0xFELL,
+                                                    -0xFELL,
+                                                    0xFFLL,
+                                                    -0xFFLL,
+                                                    0x100LL,
+                                                    -0x100LL,
+                                                    0x101LL,
+                                                    -0x101LL,
+                                                    0xFA1AFELL,
+                                                    -0xFA1AFELL,
+                                                    0xFFFFFFFELL,
+                                                    -0xFFFFFFFELL,
+                                                    0xFFFFFFFFLL,
+                                                    -0xFFFFFFFFLL,
+                                                    0x100000000LL,
+                                                    -0x100000000LL,
+                                                    0x100000001LL,
+                                                    -0x100000001LL,
+                                                    0xFFFFFFFFFFLL,
+                                                    -0xFFFFFFFFFFLL,
+                                                    0x112358132134LL,
+                                                    -0x112358132134LL,
+                                                    0xFEFFBEEFABC1234LL,
+                                                    -0xFEFFBEEFABC1234LL,
+                                                    INT64_MAX,
+                                                    INT64_MIN,
+                                                    INT64_MIN + 1,
+                                                    INT64_MAX - 1};
 
 const size_t PositionFromIntTest::kNumTestValues =
 arraysize(PositionFromIntTest::kTestValues);
 
 TEST_F(PositionFromIntTest, IsValid) {
   for (size_t i = 0; i < kNumTestValues; ++i) {
     const UniquePosition pos =
         UniquePosition::FromInt64(kTestValues[i], NextSuffix());
     EXPECT_TRUE(pos.IsValid()) << "i = " << i << "; " << pos.ToDebugString();
   }
 }
 
 TEST_F(PositionFromIntTest, RoundTripConversion) {
   for (size_t i = 0; i < kNumTestValues; ++i) {
-    const int64 expected_value = kTestValues[i];
+    const int64_t expected_value = kTestValues[i];
     const UniquePosition pos =
         UniquePosition::FromInt64(kTestValues[i], NextSuffix());
-    const int64 value = pos.ToInt64();
+    const int64_t value = pos.ToInt64();
     EXPECT_EQ(expected_value, value) << "i = " << i;
   }
 }
 
 template <typename T, typename LessThan = std::less<T> >
 class IndexedLessThan {
  public:
   IndexedLessThan(const T* values) : values_(values) {}
 
   bool operator()(int i1, int i2) {
@@ skipping 10 matching lines @@
   std::vector<int> original_ordering(kNumTestValues);
   std::vector<int> int64_ordering(kNumTestValues);
   std::vector<int> position_ordering(kNumTestValues);
   for (size_t i = 0; i < kNumTestValues; ++i) {
     positions[i] = UniquePosition::FromInt64(
         kTestValues[i], NextSuffix());
     original_ordering[i] = int64_ordering[i] = position_ordering[i] = i;
   }
 
   std::sort(int64_ordering.begin(), int64_ordering.end(),
-            IndexedLessThan<int64>(kTestValues));
+            IndexedLessThan<int64_t>(kTestValues));
   std::sort(position_ordering.begin(), position_ordering.end(),
             IndexedLessThan<UniquePosition, PositionLessThan>(positions));
   EXPECT_NE(original_ordering, int64_ordering);
   EXPECT_EQ(int64_ordering, position_ordering);
 }
 
 class CompressedPositionTest : public UniquePositionTest {
  public:
   CompressedPositionTest() {
     positions_.push_back(
@@ skipping 72 matching lines @@
 // This requires values in the test harness to be hard-coded in ascending order.
 TEST_F(CompressedPositionTest, OrderingTest) {
   for (size_t i = 0; i < positions_.size()-1; ++i) {
     EXPECT_PRED_FORMAT2(LessThan, positions_[i], positions_[i+1]);
   }
 }
 
 }  // namespace
 
 }  // namespace syncer