base: Remove the remaining usage GG_(U)INTn_C macros.

base/strings/string_number_conversions_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 "base/strings/string_number_conversions.h"
+
 #include <errno.h>
 #include <stdint.h>
 #include <stdio.h>
 
 #include <cmath>
 #include <limits>
 
 #include "base/format_macros.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 template <typename INT>
 struct IntToStringTest {
@@ skipping 206 matching lines @@
 TEST(StringNumberConversionsTest, StringToInt64) {
   static const struct {
     std::string input;
     int64 output;
     bool success;
   } cases[] = {
     {"0", 0, true},
     {"42", 42, true},
     {"-2147483648", INT_MIN, true},
     {"2147483647", INT_MAX, true},
-    {"-2147483649", GG_INT64_C(-2147483649), true},
-    {"-99999999999", GG_INT64_C(-99999999999), true},
-    {"2147483648", GG_INT64_C(2147483648), true},
-    {"99999999999", GG_INT64_C(99999999999), true},
+    {"-2147483649", INT64_C(-2147483649), true},
+    {"-99999999999", INT64_C(-99999999999), true},
+    {"2147483648", INT64_C(2147483648), true},
+    {"99999999999", INT64_C(99999999999), true},
     {"9223372036854775807", kint64max, true},
     {"-9223372036854775808", kint64min, true},
     {"09", 9, true},
     {"-09", -9, true},
     {"", 0, false},
     {" 42", 42, false},
     {"42 ", 42, false},
     {"0x42", 0, false},
     {"\t\n\v\f\r 42", 42, false},
     {"blah42", 0, false},
@@ skipping 43 matching lines @@
     std::string input;
     uint64 output;
     bool success;
   } cases[] = {
     {"0", 0, true},
     {"42", 42, true},
     {"-2147483648", 0, false},
     {"2147483647", INT_MAX, true},
     {"-2147483649", 0, false},
     {"-99999999999", 0, false},
-    {"2147483648", GG_UINT64_C(2147483648), true},
-    {"99999999999", GG_UINT64_C(99999999999), true},
+    {"2147483648", UINT64_C(2147483648), true},
+    {"99999999999", UINT64_C(99999999999), true},
     {"9223372036854775807", kint64max, true},
     {"-9223372036854775808", 0, false},
     {"09", 9, true},
     {"-09", 0, false},
     {"", 0, false},
     {" 42", 42, false},
     {"42 ", 42, false},
     {"0x42", 0, false},
     {"\t\n\v\f\r 42", 42, false},
     {"blah42", 0, false},
     {"42blah", 42, false},
     {"blah42blah", 0, false},
     {"-273.15", 0, false},
     {"+98.6", 98, false},
     {"--123", 0, false},
     {"++123", 0, false},
     {"-+123", 0, false},
     {"+-123", 0, false},
     {"-", 0, false},
     {"-9223372036854775809", 0, false},
     {"-99999999999999999999", 0, false},
-    {"9223372036854775808", GG_UINT64_C(9223372036854775808), true},
+    {"9223372036854775808", UINT64_C(9223372036854775808), true},
     {"99999999999999999999", kuint64max, false},
     {"18446744073709551615", kuint64max, true},
     {"18446744073709551616", kuint64max, false},
   };
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     uint64 output = 0;
     EXPECT_EQ(cases[i].success, StringToUint64(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
 
@@ skipping 202 matching lines @@
 TEST(StringNumberConversionsTest, HexStringToInt64) {
   static const struct {
     std::string input;
     int64 output;
     bool success;
   } cases[] = {
     {"0", 0, true},
     {"42", 66, true},
     {"-42", -66, true},
     {"+42", 66, true},
-    {"40acd88557b", GG_INT64_C(4444444448123), true},
+    {"40acd88557b", INT64_C(4444444448123), true},
     {"7fffffff", INT_MAX, true},
     {"-80000000", INT_MIN, true},
     {"ffffffff", 0xffffffff, true},
     {"DeadBeef", 0xdeadbeef, true},
     {"0x42", 66, true},
     {"-0x42", -66, true},
     {"+0x42", 66, true},
-    {"0x40acd88557b", GG_INT64_C(4444444448123), true},
+    {"0x40acd88557b", INT64_C(4444444448123), true},
     {"0x7fffffff", INT_MAX, true},
     {"-0x80000000", INT_MIN, true},
     {"0xffffffff", 0xffffffff, true},
     {"0XDeadBeef", 0xdeadbeef, true},
     {"0x7fffffffffffffff", kint64max, true},
     {"-0x8000000000000000", kint64min, true},
     {"0x8000000000000000", kint64max, false},  // Overflow test.
     {"-0x8000000000000001", kint64min, false},  // Underflow test.
     {"0x0f", 15, true},
     {"0f", 15, true},
@@ skipping 28 matching lines @@
 TEST(StringNumberConversionsTest, HexStringToUInt64) {
   static const struct {
     std::string input;
     uint64 output;
     bool success;
   } cases[] = {
     {"0", 0, true},
     {"42", 66, true},
     {"-42", 0, false},
     {"+42", 66, true},
-    {"40acd88557b", GG_INT64_C(4444444448123), true},
+    {"40acd88557b", INT64_C(4444444448123), true},
     {"7fffffff", INT_MAX, true},
     {"-80000000", 0, false},
     {"ffffffff", 0xffffffff, true},
     {"DeadBeef", 0xdeadbeef, true},
     {"0x42", 66, true},
     {"-0x42", 0, false},
     {"+0x42", 66, true},
-    {"0x40acd88557b", GG_INT64_C(4444444448123), true},
+    {"0x40acd88557b", INT64_C(4444444448123), true},
     {"0x7fffffff", INT_MAX, true},
     {"-0x80000000", 0, false},
     {"0xffffffff", 0xffffffff, true},
     {"0XDeadBeef", 0xdeadbeef, true},
     {"0x7fffffffffffffff", kint64max, true},
     {"-0x8000000000000000", 0, false},
-    {"0x8000000000000000", GG_UINT64_C(0x8000000000000000), true},
+    {"0x8000000000000000", UINT64_C(0x8000000000000000), true},
     {"-0x8000000000000001", 0, false},
     {"0xFFFFFFFFFFFFFFFF", kuint64max, true},
     {"FFFFFFFFFFFFFFFF", kuint64max, true},
     {"0x0000000000000000", 0, true},
     {"0000000000000000", 0, true},
     {"1FFFFFFFFFFFFFFFF", kuint64max, false}, // Overflow test.
     {"0x0f", 15, true},
     {"0f", 15, true},
     {" 45", 0x45, false},
     {"\t\n\v\f\r 0x45", 0x45, false},
@@ skipping 150 matching lines @@
 
 TEST(StringNumberConversionsTest, HexEncode) {
   std::string hex(HexEncode(NULL, 0));
   EXPECT_EQ(hex.length(), 0U);
   unsigned char bytes[] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0x80, 0x81};
   hex = HexEncode(bytes, sizeof(bytes));
   EXPECT_EQ(hex.compare("01FF02FE038081"), 0);
 }
 
 }  // namespace base