[Autofill] Don't fill expiration date of expired credit cards.

components/autofill/core/browser/autofill_field_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 "components/autofill/core/browser/autofill_field.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/country_names.h"
 #include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/common/autofill_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::StringToInt;
 using base::UTF8ToUTF16;
 
@@ skipping 20 matching lines @@
     "Jun",
     "Jul",
     "Aug",
     "Sep",
     "Oct",
     "Nov",
     "Dec"};
   return result;
 }
 
-// Returns a FormFieldData object corresponding to a <select> field populated
-// with the given |values| and |contents|.
-FormFieldData GenerateSelectFieldWithOptions(
-    const std::vector<const char*>& values,
-    const std::vector<const char*>& contents,
-    size_t select_size) {
-  std::vector<base::string16> values16(select_size);
-  for (size_t i = 0; i < select_size; ++i)
-    values16[i] = UTF8ToUTF16(values[i]);
-
-  std::vector<base::string16> contents16(select_size);
-  for (size_t i = 0; i < select_size; ++i)
-    contents16[i] = UTF8ToUTF16(contents[i]);
-
-  FormFieldData form_field;
-  form_field.form_control_type = "select-one";
-  form_field.option_values = values16;
-  form_field.option_contents = contents16;
-  return form_field;
-}
-
-// Returns a FormFieldData object corresponding to a <select> field populated
-// with the given |values|.
-FormFieldData GenerateSelectFieldWithOptions(
-    const std::vector<const char*>& values,
-    size_t select_size) {
-  return GenerateSelectFieldWithOptions(values, values, select_size);
-}
-
 // Returns the index of |value| in |values|.
 void GetIndexOfValue(const std::vector<base::string16>& values,
                      const base::string16& value,
                      size_t* index) {
   for (size_t i = 0; i < values.size(); ++i) {
     if (values[i] == value) {
       *index = i;
       return;
     }
   }
   ASSERT_TRUE(false) << "Passing invalid arguments to GetIndexOfValue";
 }
 
 // Creates the select field from the specified |values| and |contents| and tests
 // filling with 3 different values.
 void TestFillingExpirationMonth(const std::vector<const char*>& values,
                                 const std::vector<const char*>& contents,
                                 size_t select_size) {
   // Create the select field.
-  AutofillField field(
-      GenerateSelectFieldWithOptions(values, contents, select_size),
-      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField("", "", "", values, contents, select_size,
+                              &field);
   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 
   size_t content_index = 0;
 
   // Try with a leading zero.
   AutofillField::FillFormField(field, ASCIIToUTF16("03"), "en-US", "en-US",
                                &field);
   GetIndexOfValue(field.option_values, field.value, &content_index);
   EXPECT_EQ(ASCIIToUTF16("Mar"), field.option_contents[content_index]);
 
@@ skipping 241 matching lines @@
     AutofillField::FillFormField(field, ASCIIToUTF16(test_case.value_to_fill),
                                  "en-US", "en-US", &field);
     EXPECT_EQ(ASCIIToUTF16(test_case.expected_value), field.value);
   }
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlByValue) {
   std::vector<const char*> kOptions = {
       "Eenie", "Meenie", "Miney", "Mo",
   };
-  AutofillField field(GenerateSelectFieldWithOptions(kOptions, kOptions.size()),
-                      base::string16());
+
+  AutofillField field;
+  test::CreateTestSelectField(kOptions, &field);
 
   // Set semantically empty contents for each option, so that only the values
   // can be used for matching.
   for (size_t i = 0; i < field.option_contents.size(); ++i)
     field.option_contents[i] = base::SizeTToString16(i);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("Meenie"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("Meenie"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlByContents) {
   std::vector<const char*> kOptions = {
       "Eenie", "Meenie", "Miney", "Mo",
   };
-  AutofillField field(GenerateSelectFieldWithOptions(kOptions, kOptions.size()),
-                      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kOptions, &field);
 
   // Set semantically empty values for each option, so that only the contents
   // can be used for matching.
   for (size_t i = 0; i < field.option_values.size(); ++i)
     field.option_values[i] = base::SizeTToString16(i);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("Miney"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("2"), field.value);  // Corresponds to "Miney".
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithFullCountryNames) {
   std::vector<const char*> kCountries = {"Albania", "Canada"};
-  AutofillField field(
-      GenerateSelectFieldWithOptions(kCountries, kCountries.size()),
-      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kCountries, &field);
   field.set_heuristic_type(ADDRESS_HOME_COUNTRY);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("CA"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("Canada"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithAbbreviatedCountryNames) {
   std::vector<const char*> kCountries = {"AL", "CA"};
-  AutofillField field(
-      GenerateSelectFieldWithOptions(kCountries, kCountries.size()),
-      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kCountries, &field);
   field.set_heuristic_type(ADDRESS_HOME_COUNTRY);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("Canada"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("CA"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithFullStateNames) {
   std::vector<const char*> kStates = {"Alabama", "California"};
-  AutofillField field(GenerateSelectFieldWithOptions(kStates, kStates.size()),
-                      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kStates, &field);
   field.set_heuristic_type(ADDRESS_HOME_STATE);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("CA"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("California"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithAbbreviateStateNames) {
   std::vector<const char*> kStates = {"AL", "CA"};
-  AutofillField field(GenerateSelectFieldWithOptions(kStates, kStates.size()),
-                      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kStates, &field);
   field.set_heuristic_type(ADDRESS_HOME_STATE);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("California"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("CA"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithInexactFullStateNames) {
   {
     std::vector<const char*> kStates = {
         "SC - South Carolina", "CA - California", "NC - North Carolina",
     };
-    AutofillField field(GenerateSelectFieldWithOptions(kStates, kStates.size()),
-                        base::string16());
+    AutofillField field;
+    test::CreateTestSelectField(kStates, &field);
     field.set_heuristic_type(ADDRESS_HOME_STATE);
 
     AutofillField::FillFormField(
         field, ASCIIToUTF16("California"), "en-US", "en-US", &field);
     EXPECT_EQ(ASCIIToUTF16("CA - California"), field.value);
   }
 
   // Don't accidentally match "Virginia" to "West Virginia".
   {
     std::vector<const char*> kStates = {
         "WV - West Virginia", "VA - Virginia", "NV - North Virginia",
     };
-    AutofillField field(GenerateSelectFieldWithOptions(kStates, kStates.size()),
-                        base::string16());
+    AutofillField field;
+    test::CreateTestSelectField(kStates, &field);
     field.set_heuristic_type(ADDRESS_HOME_STATE);
 
     AutofillField::FillFormField(
         field, ASCIIToUTF16("Virginia"), "en-US", "en-US", &field);
     EXPECT_EQ(ASCIIToUTF16("VA - Virginia"), field.value);
   }
 
   // Do accidentally match "Virginia" to "West Virginia". NB: Ideally, Chrome
   // would fail this test. It's here to document behavior rather than enforce
   // it.
   {
     std::vector<const char*> kStates = {
         "WV - West Virginia", "TX - Texas",
     };
-    AutofillField field(GenerateSelectFieldWithOptions(kStates, kStates.size()),
-                        base::string16());
+    AutofillField field;
+    test::CreateTestSelectField(kStates, &field);
     field.set_heuristic_type(ADDRESS_HOME_STATE);
 
     AutofillField::FillFormField(
         field, ASCIIToUTF16("Virginia"), "en-US", "en-US", &field);
     EXPECT_EQ(ASCIIToUTF16("WV - West Virginia"), field.value);
   }
 
   // Tests that substring matches work for full state names (a full token
   // match isn't required). Also tests that matches work for states with
   // whitespace in the middle.
   {
     std::vector<const char*> kStates = {
         "California.", "North Carolina.",
     };
-    AutofillField field(GenerateSelectFieldWithOptions(kStates, kStates.size()),
-                        base::string16());
+    AutofillField field;
+    test::CreateTestSelectField(kStates, &field);
     field.set_heuristic_type(ADDRESS_HOME_STATE);
 
     AutofillField::FillFormField(
         field, ASCIIToUTF16("North Carolina"), "en-US", "en-US", &field);
     EXPECT_EQ(ASCIIToUTF16("North Carolina."), field.value);
   }
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithInexactAbbreviations) {
   {
     std::vector<const char*> kStates = {
         "NC - North Carolina", "CA - California",
     };
-    AutofillField field(GenerateSelectFieldWithOptions(kStates, kStates.size()),
-                        base::string16());
+    AutofillField field;
+    test::CreateTestSelectField(kStates, &field);
     field.set_heuristic_type(ADDRESS_HOME_STATE);
 
     AutofillField::FillFormField(
         field, ASCIIToUTF16("CA"), "en-US", "en-US", &field);
     EXPECT_EQ(ASCIIToUTF16("CA - California"), field.value);
   }
 
   {
     std::vector<const char*> kNotStates = {
         "NCNCA", "SCNCA",
     };
-    AutofillField field(
-        GenerateSelectFieldWithOptions(kNotStates, kNotStates.size()),
-        base::string16());
+    AutofillField field;
+    test::CreateTestSelectField(kNotStates, &field);
     field.set_heuristic_type(ADDRESS_HOME_STATE);
 
     AutofillField::FillFormField(
         field, ASCIIToUTF16("NC"), "en-US", "en-US", &field);
     EXPECT_EQ(base::string16(), field.value);
   }
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithExpirationMonth) {
   typedef struct {
@@ skipping 44 matching lines @@
                                test_case.select_contents,
                                test_case.select_values.size());
   }
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithAbbreviatedMonthName) {
   std::vector<const char*> kMonthsAbbreviated = {
       "Jan", "Feb", "Mar", "Apr", "May", "Jun",
       "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
   };
-  AutofillField field(GenerateSelectFieldWithOptions(kMonthsAbbreviated,
-                                                     kMonthsAbbreviated.size()),
-                      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kMonthsAbbreviated, &field);
   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("04"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("Apr"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithFullMonthName) {
   std::vector<const char*> kMonthsFull = {
       "January", "February", "March",     "April",   "May",      "June",
       "July",    "August",   "September", "October", "November", "December",
   };
-  AutofillField field(
-      GenerateSelectFieldWithOptions(kMonthsFull, kMonthsFull.size()),
-      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kMonthsFull, &field);
   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("04"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("April"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithFrenchMonthName) {
   std::vector<const char*> kMonthsFrench = {"JANV", "FÉVR.", "MARS",
                                             "décembre"};
-  AutofillField field(
-      GenerateSelectFieldWithOptions(kMonthsFrench, kMonthsFrench.size()),
-      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kMonthsFrench, &field);
   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("02"), "fr-FR", "fr-FR", &field);
   EXPECT_EQ(UTF8ToUTF16("FÉVR."), field.value);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("01"), "fr-FR", "fr-FR", &field);
   EXPECT_EQ(UTF8ToUTF16("JANV"), field.value);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("12"), "fr-FR", "fr-FR", &field);
   EXPECT_EQ(UTF8ToUTF16("décembre"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithNumericMonthSansLeadingZero) {
   std::vector<const char*> kMonthsNumeric = {
       "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
   };
-  AutofillField field(
-      GenerateSelectFieldWithOptions(kMonthsNumeric, kMonthsNumeric.size()),
-      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kMonthsNumeric, &field);
   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("04"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("4"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithTwoDigitCreditCardYear) {
   std::vector<const char*> kYears = {"12", "13", "14", "15",
                                      "16", "17", "18", "19"};
-  AutofillField field(GenerateSelectFieldWithOptions(kYears, kYears.size()),
-                      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kYears, &field);
   field.set_heuristic_type(CREDIT_CARD_EXP_2_DIGIT_YEAR);
 
   AutofillField::FillFormField(
       field, ASCIIToUTF16("2017"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("17"), field.value);
 }
 
 TEST_F(AutofillFieldTest, FillSelectControlWithCreditCardType) {
   std::vector<const char*> kCreditCardTypes = {"Visa", "Master Card", "AmEx",
                                                "discover"};
-  AutofillField field(
-      GenerateSelectFieldWithOptions(kCreditCardTypes, kCreditCardTypes.size()),
-      base::string16());
+  AutofillField field;
+  test::CreateTestSelectField(kCreditCardTypes, &field);
   field.set_heuristic_type(CREDIT_CARD_TYPE);
 
   // Normal case:
   AutofillField::FillFormField(
       field, ASCIIToUTF16("Visa"), "en-US", "en-US", &field);
   EXPECT_EQ(ASCIIToUTF16("Visa"), field.value);
 
   // Filling should be able to handle intervening whitespace:
   AutofillField::FillFormField(
       field, ASCIIToUTF16("MasterCard"), "en-US", "en-US", &field);
@@ skipping 163 matching lines @@
                                "en-US",
                                "en-US",
                                &cc_number_full);
 
   // Verify for expected results.
   EXPECT_EQ(ASCIIToUTF16(test.card_number_), cc_number_full.value);
 }
 
 TEST_F(AutofillFieldTest, FindShortestSubstringMatchInSelect) {
   std::vector<const char*> kCountries = {"États-Unis", "Canada"};
-  FormFieldData field(
-      GenerateSelectFieldWithOptions(kCountries, kCountries.size()));
+  AutofillField field;
+  test::CreateTestSelectField(kCountries, &field);
 
   // Case 1: Exact match
   int ret = AutofillField::FindShortestSubstringMatchInSelect(
       ASCIIToUTF16("Canada"), false, &field);
   EXPECT_EQ(1, ret);
 
   // Case 2: Case-insensitive
   ret = AutofillField::FindShortestSubstringMatchInSelect(
       ASCIIToUTF16("CANADA"), false, &field);
   EXPECT_EQ(1, ret);
@@ skipping 66 matching lines @@
     bool has_filled = AutofillField::FillFormField(
         field, ASCIIToUTF16(test_case.value_to_fill), "en-US", "en-US", &field);
 
     EXPECT_EQ(test_case.should_fill, has_filled);
     EXPECT_EQ(ASCIIToUTF16(test_case.expected_value), field.value);
   }
 }
 
 }  // namespace
 }  // namespace autofill