Convert ARRAYSIZE_UNSAFE -> arraysize in base/.

base/strings/string_util_unittest.cc

 // Copyright 2013 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_util.h"
 
 #include <math.h>
 #include <stdarg.h>
 
 #include <algorithm>
@@ skipping 521 matching lines @@
 TEST(StringUtilTest, LowerCaseEqualsASCII) {
   static const struct {
     const char*    src_a;
     const char*    dst;
   } lowercase_cases[] = {
     { "FoO", "foo" },
     { "foo", "foo" },
     { "FOO", "foo" },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(lowercase_cases); ++i) {
+  for (size_t i = 0; i < arraysize(lowercase_cases); ++i) {
     EXPECT_TRUE(LowerCaseEqualsASCII(ASCIIToUTF16(lowercase_cases[i].src_a),
                                      lowercase_cases[i].dst));
     EXPECT_TRUE(LowerCaseEqualsASCII(lowercase_cases[i].src_a,
                                      lowercase_cases[i].dst));
   }
 }
 
 TEST(StringUtilTest, FormatBytesUnlocalized) {
   static const struct {
     int64 bytes;
@@ skipping 16 matching lines @@
     {~(1LL<<63), "8192 PB"},
 
     {99*1024 + 103, "99.1 kB"},
     {1024*1024 + 103, "1.0 MB"},
     {1024*1024 + 205 * 1024, "1.2 MB"},
     {1024*1024*1024 + (927 * 1024*1024), "1.9 GB"},
     {10LL*1024*1024*1024, "10.0 GB"},
     {100LL*1024*1024*1024, "100 GB"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     EXPECT_EQ(ASCIIToUTF16(cases[i].expected),
               FormatBytesUnlocalized(cases[i].bytes));
   }
 }
 TEST(StringUtilTest, ReplaceSubstringsAfterOffset) {
   static const struct {
     const char* str;
     string16::size_type start_offset;
     const char* find_this;
     const char* replace_with;
     const char* expected;
   } cases[] = {
     {"aaa", 0, "a", "b", "bbb"},
     {"abb", 0, "ab", "a", "ab"},
     {"Removing some substrings inging", 0, "ing", "", "Remov some substrs "},
     {"Not found", 0, "x", "0", "Not found"},
     {"Not found again", 5, "x", "0", "Not found again"},
     {" Making it much longer ", 0, " ", "Four score and seven years ago",
      "Four score and seven years agoMakingFour score and seven years agoit"
      "Four score and seven years agomuchFour score and seven years agolonger"
      "Four score and seven years ago"},
     {"Invalid offset", 9999, "t", "foobar", "Invalid offset"},
     {"Replace me only me once", 9, "me ", "", "Replace me only once"},
     {"abababab", 2, "ab", "c", "abccc"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     string16 str = ASCIIToUTF16(cases[i].str);
     ReplaceSubstringsAfterOffset(&str, cases[i].start_offset,
                                  ASCIIToUTF16(cases[i].find_this),
                                  ASCIIToUTF16(cases[i].replace_with));
     EXPECT_EQ(ASCIIToUTF16(cases[i].expected), str);
   }
 }
 
 TEST(StringUtilTest, ReplaceFirstSubstringAfterOffset) {
   static const struct {
     const char* str;
     string16::size_type start_offset;
     const char* find_this;
     const char* replace_with;
     const char* expected;
   } cases[] = {
     {"aaa", 0, "a", "b", "baa"},
     {"abb", 0, "ab", "a", "ab"},
     {"Removing some substrings inging", 0, "ing", "",
       "Remov some substrings inging"},
     {"Not found", 0, "x", "0", "Not found"},
     {"Not found again", 5, "x", "0", "Not found again"},
     {" Making it much longer ", 0, " ", "Four score and seven years ago",
      "Four score and seven years agoMaking it much longer "},
     {"Invalid offset", 9999, "t", "foobar", "Invalid offset"},
     {"Replace me only me once", 4, "me ", "", "Replace only me once"},
     {"abababab", 2, "ab", "c", "abcabab"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     string16 str = ASCIIToUTF16(cases[i].str);
     ReplaceFirstSubstringAfterOffset(&str, cases[i].start_offset,
                                      ASCIIToUTF16(cases[i].find_this),
                                      ASCIIToUTF16(cases[i].replace_with));
     EXPECT_EQ(ASCIIToUTF16(cases[i].expected), str);
   }
 }
 
 TEST(StringUtilTest, HexDigitToInt) {
   EXPECT_EQ(0, HexDigitToInt('0'));
@@ skipping 494 matching lines @@
     { L"%f", true },
     { L"%f %F", false },
     { L"%d %D", false },
     { L"%o %O", false },
     { L"%u %U", false },
     { L"%f %d %o %u", true },
     { L"%-8d (%02.1f%)", true },
     { L"% 10s", false },
     { L"% 10ls", true }
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i)
+  for (size_t i = 0; i < arraysize(cases); ++i)
     EXPECT_EQ(cases[i].portable, base::IsWprintfFormatPortable(cases[i].input));
 }
 
 TEST(StringUtilTest, RemoveChars) {
   const char* kRemoveChars = "-/+*";
   std::string input = "A-+bc/d!*";
   EXPECT_TRUE(RemoveChars(input, kRemoveChars, &input));
   EXPECT_EQ("Abcd!", input);
 
   // No characters match kRemoveChars.
@@ skipping 22 matching lines @@
     { "test", "e", "!?", "t!?st", true },
     { "test", "ez", "!", "t!st", true },
     { "test", "zed", "!?", "t!?st", true },
     { "test", "t", "!?", "!?es!?", true },
     { "test", "et", "!>", "!>!>s!>", true },
     { "test", "zest", "!", "!!!!", true },
     { "test", "szt", "!", "!e!!", true },
     { "test", "t", "test", "testestest", true },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     std::string output;
     bool result = ReplaceChars(cases[i].input,
                                cases[i].replace_chars,
                                cases[i].replace_with,
                                &output);
     EXPECT_EQ(cases[i].result, result);
     EXPECT_EQ(cases[i].output, output);
   }
 }
 
@@ skipping 54 matching lines @@
   const std::string live = kLive;
   std::string dead = live;
   strncpy(WriteInto(&dead, 5), kDead, 4);
   EXPECT_EQ(kDead, dead);
   EXPECT_EQ(4u, dead.size());
   EXPECT_EQ(kLive, live);
   EXPECT_EQ(4u, live.size());
 }
 
 }  // namespace base