Convert ARRAYSIZE_UNSAFE -> arraysize in base/.

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 <errno.h>
 #include <stdint.h>
 #include <stdio.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 55 matching lines @@
   static const struct {
     uint64 input;
     std::string output;
   } cases[] = {
     {0, "0"},
     {42, "42"},
     {INT_MAX, "2147483647"},
     {kuint64max, "18446744073709551615"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i)
+  for (size_t i = 0; i < arraysize(cases); ++i)
     EXPECT_EQ(cases[i].output, Uint64ToString(cases[i].input));
 }
 
 TEST(StringNumberConversionsTest, SizeTToString) {
   size_t size_t_max = std::numeric_limits<size_t>::max();
   std::string size_t_max_string = StringPrintf("%" PRIuS, size_t_max);
 
   static const struct {
     size_t input;
     std::string output;
   } cases[] = {
     {0, "0"},
     {9, "9"},
     {42, "42"},
     {INT_MAX, "2147483647"},
     {2147483648U, "2147483648"},
 #if SIZE_MAX > 4294967295U
     {99999999999U, "99999999999"},
 #endif
     {size_t_max, size_t_max_string},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i)
+  for (size_t i = 0; i < arraysize(cases); ++i)
     EXPECT_EQ(cases[i].output, Uint64ToString(cases[i].input));
 }
 
 TEST(StringNumberConversionsTest, StringToInt) {
   static const struct {
     std::string input;
     int output;
     bool success;
   } cases[] = {
     {"0", 0, true},
@@ skipping 15 matching lines @@
     {"++123", 0, false},
     {"-+123", 0, false},
     {"+-123", 0, false},
     {"-", 0, false},
     {"-2147483649", INT_MIN, false},
     {"-99999999999", INT_MIN, false},
     {"2147483648", INT_MAX, false},
     {"99999999999", INT_MAX, false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     int output = 0;
     EXPECT_EQ(cases[i].success, StringToInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
 
     string16 utf16_input = UTF8ToUTF16(cases[i].input);
     output = 0;
     EXPECT_EQ(cases[i].success, StringToInt(utf16_input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
 
@@ skipping 43 matching lines @@
     {"-+123", 0, false},
     {"+-123", 0, false},
     {"-", 0, false},
     {"-2147483649", 0, false},
     {"-99999999999", 0, false},
     {"4294967295", UINT_MAX, true},
     {"4294967296", UINT_MAX, false},
     {"99999999999", UINT_MAX, false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     unsigned output = 0;
     EXPECT_EQ(cases[i].success, StringToUint(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
 
     string16 utf16_input = UTF8ToUTF16(cases[i].input);
     output = 0;
     EXPECT_EQ(cases[i].success, StringToUint(utf16_input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
 
@@ skipping 49 matching lines @@
     {"++123", 0, false},
     {"-+123", 0, false},
     {"+-123", 0, false},
     {"-", 0, false},
     {"-9223372036854775809", kint64min, false},
     {"-99999999999999999999", kint64min, false},
     {"9223372036854775808", kint64max, false},
     {"99999999999999999999", kint64max, false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     int64 output = 0;
     EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
 
     string16 utf16_input = UTF8ToUTF16(cases[i].input);
     output = 0;
     EXPECT_EQ(cases[i].success, StringToInt64(utf16_input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
 
@@ skipping 46 matching lines @@
     {"+-123", 0, false},
     {"-", 0, false},
     {"-9223372036854775809", 0, false},
     {"-99999999999999999999", 0, false},
     {"9223372036854775808", GG_UINT64_C(9223372036854775808), true},
     {"99999999999999999999", kuint64max, false},
     {"18446744073709551615", kuint64max, true},
     {"18446744073709551616", kuint64max, false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  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);
 
     string16 utf16_input = UTF8ToUTF16(cases[i].input);
     output = 0;
     EXPECT_EQ(cases[i].success, StringToUint64(utf16_input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
 
@@ skipping 48 matching lines @@
     {"++123", 0, false},
     {"-+123", 0, false},
     {"+-123", 0, false},
     {"-", 0, false},
     {"-9223372036854775809", 0, false},
     {"-99999999999999999999", 0, false},
     {"999999999999999999999999", size_t_max, false},
     {size_t_max_string, size_t_max, true},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     size_t output = 0;
     EXPECT_EQ(cases[i].success, StringToSizeT(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
 
     string16 utf16_input = UTF8ToUTF16(cases[i].input);
     output = 0;
     EXPECT_EQ(cases[i].success, StringToSizeT(utf16_input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
 
@@ skipping 42 matching lines @@
     {"45 ", 0x45, false},
     {"45:", 0x45, false},
     {"efgh", 0xef, false},
     {"0xefgh", 0xef, false},
     {"hgfe", 0, false},
     {"-", 0, false},
     {"", 0, false},
     {"0x", 0, false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     int output = 0;
     EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
   const char input[] = "0xc0ffee\0" "9";
   std::string input_string(input, arraysize(input) - 1);
   int output;
@@ skipping 39 matching lines @@
     {"45 ", 0x45, false},
     {"45:", 0x45, false},
     {"efgh", 0xef, false},
     {"0xefgh", 0xef, false},
     {"hgfe", 0, false},
     {"-", 0, false},
     {"", 0, false},
     {"0x", 0, false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     uint32 output = 0;
     EXPECT_EQ(cases[i].success, HexStringToUInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
   const char input[] = "0xc0ffee\0" "9";
   std::string input_string(input, arraysize(input) - 1);
   uint32 output;
@@ skipping 36 matching lines @@
     {"45 ", 0x45, false},
     {"45:", 0x45, false},
     {"efgh", 0xef, false},
     {"0xefgh", 0xef, false},
     {"hgfe", 0, false},
     {"-", 0, false},
     {"", 0, false},
     {"0x", 0, false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     int64 output = 0;
     EXPECT_EQ(cases[i].success, HexStringToInt64(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
   const char input[] = "0xc0ffee\0" "9";
   std::string input_string(input, arraysize(input) - 1);
   int64 output;
@@ skipping 41 matching lines @@
     {"45 ", 0x45, false},
     {"45:", 0x45, false},
     {"efgh", 0xef, false},
     {"0xefgh", 0xef, false},
     {"hgfe", 0, false},
     {"-", 0, false},
     {"", 0, false},
     {"0x", 0, false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     uint64 output = 0;
     EXPECT_EQ(cases[i].success, HexStringToUInt64(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
   const char input[] = "0xc0ffee\0" "9";
   std::string input_string(input, arraysize(input) - 1);
   uint64 output;
@@ skipping 21 matching lines @@
     {"0f", "\xf", 1, true},
     {"45  ", "\x45", 1, false},
     {"efgh", "\xef", 1, false},
     {"", "", 0, false},
     {"0123456789ABCDEF", "\x01\x23\x45\x67\x89\xAB\xCD\xEF", 8, true},
     {"0123456789ABCDEF012345",
      "\x01\x23\x45\x67\x89\xAB\xCD\xEF\x01\x23\x45", 11, true},
   };
 
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     std::vector<uint8> output;
     std::vector<uint8> compare;
     EXPECT_EQ(cases[i].success, HexStringToBytes(cases[i].input, &output)) <<
         i << ": " << cases[i].input;
     for (size_t j = 0; j < cases[i].output_len; ++j)
       compare.push_back(static_cast<uint8>(cases[i].output[j]));
     ASSERT_EQ(output.size(), compare.size()) << i << ": " << cases[i].input;
     EXPECT_TRUE(std::equal(output.begin(), output.end(), compare.begin())) <<
         i << ": " << cases[i].input;
   }
@@ skipping 28 matching lines @@
     {"123e ", 123.0, false},
     {"123e", 123.0, false},
     {" 2.99", 2.99, false},
     {"1e3.4", 1000.0, false},
     {"nothing", 0.0, false},
     {"-", 0.0, false},
     {"+", 0.0, false},
     {"", 0.0, false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     double output;
     errno = 1;
     EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output));
     if (cases[i].success)
       EXPECT_EQ(1, errno) << i;  // confirm that errno is unchanged.
     EXPECT_DOUBLE_EQ(cases[i].output, output);
   }
 
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
@@ skipping 12 matching lines @@
   } cases[] = {
     {0.0, "0"},
     {1.25, "1.25"},
     {1.33518e+012, "1.33518e+12"},
     {1.33489e+012, "1.33489e+12"},
     {1.33505e+012, "1.33505e+12"},
     {1.33545e+009, "1335450000"},
     {1.33503e+009, "1335030000"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     EXPECT_EQ(cases[i].expected, DoubleToString(cases[i].input));
   }
 
   // The following two values were seen in crashes in the wild.
   const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'};
   double input = 0;
   memcpy(&input, input_bytes, arraysize(input_bytes));
   EXPECT_EQ("1335179083776", DoubleToString(input));
   const char input_bytes2[8] =
       {0, 0, 0, '\xa0', '\xda', '\x6c', '\x73', '\x42'};
   input = 0;
   memcpy(&input, input_bytes2, arraysize(input_bytes2));
   EXPECT_EQ("1334890332160", DoubleToString(input));
 }
 
 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