Reland of place for loops with |arraysize| with for each loops

components/autofill/core/browser/credit_card_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 <stddef.h>
 
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 164 matching lines @@
       {"45", 2045},
       {"045", 2045},
       {"9", 2009},
 
       // Unrecognized year values.
       {"052045", 0},
       {"123", 0},
       {"y2045", 0},
   };
 
-  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
+  for (const auto& test_case : kTestCases) {
     CreditCard card(base::GenerateGUID(), "some origin");
-    card.SetExpirationYearFromString(
-        ASCIIToUTF16(kTestCases[i].expiration_year));
+    card.SetExpirationYearFromString(ASCIIToUTF16(test_case.expiration_year));
 
-    EXPECT_EQ(kTestCases[i].expected_year, card.expiration_year())
-        << kTestCases[i].expiration_year << " " << kTestCases[i].expected_year;
+    EXPECT_EQ(test_case.expected_year, card.expiration_year())
+        << test_case.expiration_year << " " << test_case.expected_year;
   }
 }
 
 TEST(CreditCardTest, SetExpirationDateFromString) {
   static const struct {
     std::string expiration_date;
     int expected_month;
     int expected_year;
   } kTestCases[] = {{"10", 0, 0},       // Too small.
                     {"1020451", 0, 0},  // Too long.
@@ skipping 19 matching lines @@
                     {"5|2045", 5, 2045},
                     {"05|2045", 5, 2045},
 
                     // Invalid values.
                     {"13/2016", 0, 2016},
                     {"16/13", 0, 2013},
                     {"May-2015", 0, 0},
                     {"05-/2045", 0, 0},
                     {"05_2045", 0, 0}};
 
-  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
+  for (const auto& test_case : kTestCases) {
     CreditCard card(base::GenerateGUID(), "some origin");
-    card.SetExpirationDateFromString(
-        ASCIIToUTF16(kTestCases[i].expiration_date));
+    card.SetExpirationDateFromString(ASCIIToUTF16(test_case.expiration_date));
 
-    EXPECT_EQ(kTestCases[i].expected_month, card.expiration_month());
-    EXPECT_EQ(kTestCases[i].expected_year, card.expiration_year());
+    EXPECT_EQ(test_case.expected_month, card.expiration_month());
+    EXPECT_EQ(test_case.expected_year, card.expiration_year());
   }
 }
 
 TEST(CreditCardTest, Copy) {
   CreditCard a(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&a, "John Dillinger", "123456789012", "01", "2010");
 
   // Clone should be logically equal to the original.
   CreditCard b(a);
   EXPECT_TRUE(a == b);
@@ skipping 38 matching lines @@
       MASKED_SERVER_CARD, "John Dillinger", "9012", "01", "2010", kVisaCard,
       true },
     { LOCAL_CARD, "", "423456789012", "", "",
       MASKED_SERVER_CARD, "John Dillinger", "9012", "01", "2010", kMasterCard,
       false },
     { LOCAL_CARD, "John Dillinger", "4234-5678-9012", "01", "2010",
       FULL_SERVER_CARD, "John Dillinger", "423456789012", "01", "2010", nullptr,
       true },
   };
 
-  for (size_t i = 0; i < arraysize(test_cases); ++i) {
+  for (const auto& test_case : test_cases) {
     CreditCard a(base::GenerateGUID(), std::string());
-    a.set_record_type(test_cases[i].first_card_record_type);
-    test::SetCreditCardInfo(&a,
-                            test_cases[i].first_card_name,
-                            test_cases[i].first_card_number,
-                            test_cases[i].first_card_exp_mo,
-                            test_cases[i].first_card_exp_yr);
+    a.set_record_type(test_case.first_card_record_type);
+    test::SetCreditCardInfo(
+        &a, test_case.first_card_name, test_case.first_card_number,
+        test_case.first_card_exp_mo, test_case.first_card_exp_yr);
 
     CreditCard b(base::GenerateGUID(), std::string());
-    b.set_record_type(test_cases[i].second_card_record_type);
-    test::SetCreditCardInfo(&b,
-                            test_cases[i].second_card_name,
-                            test_cases[i].second_card_number,
-                            test_cases[i].second_card_exp_mo,
-                            test_cases[i].second_card_exp_yr);
+    b.set_record_type(test_case.second_card_record_type);
+    test::SetCreditCardInfo(
+        &b, test_case.second_card_name, test_case.second_card_number,
+        test_case.second_card_exp_mo, test_case.second_card_exp_yr);
 
-    if (test_cases[i].second_card_record_type == CreditCard::MASKED_SERVER_CARD)
-      b.SetTypeForMaskedCard(test_cases[i].second_card_type);
+    if (test_case.second_card_record_type == CreditCard::MASKED_SERVER_CARD)
+      b.SetTypeForMaskedCard(test_case.second_card_type);
 
-    EXPECT_EQ(test_cases[i].is_local_duplicate,
-              a.IsLocalDuplicateOfServerCard(b)) << " when comparing cards "
-                  << a.Label() << " and " << b.Label();
+    EXPECT_EQ(test_case.is_local_duplicate, a.IsLocalDuplicateOfServerCard(b))
+        << " when comparing cards " << a.Label() << " and " << b.Label();
   }
 }
 
 TEST(CreditCardTest, HasSameNumberAs) {
   CreditCard a(base::GenerateGUID(), std::string());
   CreditCard b(base::GenerateGUID(), std::string());
 
   // Empty cards have the same empty number.
   EXPECT_TRUE(a.HasSameNumberAs(b));
   EXPECT_TRUE(b.HasSameNumberAs(a));
@@ skipping 204 matching lines @@
                   base::IntToString16(now_exploded.year - 1));
   card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111111111111111"));
   EXPECT_FALSE(card.IsValid());
 
   // Invalid because card number is not complete
   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("12"));
   card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2999"));
   card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("41111"));
   EXPECT_FALSE(card.IsValid());
 
-  for (size_t i = 0; i < arraysize(kValidNumbers); ++i) {
-    SCOPED_TRACE(kValidNumbers[i]);
-    card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(kValidNumbers[i]));
+  for (const char* valid_number : kValidNumbers) {
+    SCOPED_TRACE(valid_number);
+    card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(valid_number));
     EXPECT_TRUE(card.IsValid());
   }
-  for (size_t i = 0; i < arraysize(kInvalidNumbers); ++i) {
-    SCOPED_TRACE(kInvalidNumbers[i]);
-    card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(kInvalidNumbers[i]));
+  for (const char* invalid_number : kInvalidNumbers) {
+    SCOPED_TRACE(invalid_number);
+    card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(invalid_number));
     EXPECT_FALSE(card.IsValid());
   }
 }
 
 // Verify that we preserve exactly what the user typed for credit card numbers.
 TEST(CreditCardTest, SetRawInfoCreditCardNumber) {
   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 
   test::SetCreditCardInfo(&card, "Bob Dylan",
                           "4321-5432-6543-xxxx", "07", "2013");
@@ skipping 205 matching lines @@
     { "68", kGenericCard, false },
     { "69", kGenericCard, false },
     { "7", kGenericCard, false },
     { "8", kGenericCard, false },
     { "9", kGenericCard, false },
 
     // Oddball case: Unknown issuer, but valid Luhn check and plausible length.
     { "7000700070007000", kGenericCard, true },
   };
 
-  for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    base::string16 card_number = ASCIIToUTF16(test_cases[i].card_number);
+  for (const auto& test_case : test_cases) {
+    base::string16 card_number = ASCIIToUTF16(test_case.card_number);
     SCOPED_TRACE(card_number);
-    EXPECT_EQ(test_cases[i].type, CreditCard::GetCreditCardType(card_number));
-    EXPECT_EQ(test_cases[i].is_valid, IsValidCreditCardNumber(card_number));
+    EXPECT_EQ(test_case.type, CreditCard::GetCreditCardType(card_number));
+    EXPECT_EQ(test_case.is_valid, IsValidCreditCardNumber(card_number));
   }
 }
 
 TEST(CreditCardTest, LastFourDigits) {
   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
   ASSERT_EQ(base::string16(), card.LastFourDigits());
 
   test::SetCreditCardInfo(&card, "Baby Face Nelson",
                           "5212341234123489", "01", "2010");
   ASSERT_EQ(base::ASCIIToUTF16("3489"), card.LastFourDigits());
@@ skipping 84 matching lines @@
       {false, next_year.month, next_year.year, CreditCard::MASKED_SERVER_CARD,
        CreditCard::OK},
       {false, next_year.month, next_year.year, CreditCard::FULL_SERVER_CARD,
        CreditCard::OK},
       {true, next_year.month, next_year.year, CreditCard::MASKED_SERVER_CARD,
        CreditCard::EXPIRED},
       {true, next_year.month, next_year.year, CreditCard::FULL_SERVER_CARD,
        CreditCard::EXPIRED},
   };
 
-  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
+  for (const auto& test_case : kTestCases) {
     CreditCard card;
-    card.SetExpirationMonth(kTestCases[i].month);
-    card.SetExpirationYear(kTestCases[i].year);
-    card.set_record_type(kTestCases[i].record_type);
+    card.SetExpirationMonth(test_case.month);
+    card.SetExpirationYear(test_case.year);
+    card.set_record_type(test_case.record_type);
     if (card.record_type() != CreditCard::LOCAL_CARD)
-      card.SetServerStatus(kTestCases[i].server_status);
+      card.SetServerStatus(test_case.server_status);
 
-    EXPECT_EQ(kTestCases[i].should_update_expiration,
+    EXPECT_EQ(test_case.should_update_expiration,
               card.ShouldUpdateExpiration(now));
   }
 }
 
 }  // namespace autofill