components/autofill/core/browser/autofill_field_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/autofill/core/browser/autofill_field.h"
   6
   7 #include "base/strings/string_number_conversions.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "components/autofill/core/browser/autofill_type.h"
  11 #include "components/autofill/core/browser/field_types.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using base::ASCIIToUTF16;
  15 using base::UTF8ToUTF16;
  16
  17 namespace autofill {
  18 namespace {
  19
  20 // Returns a FormFieldData object corresponding to a <select> field populated
  21 // with the given |options|.
  22 FormFieldData GenerateSelectFieldWithOptions(const char* const* options,
  23                                              size_t options_size) {
  24   std::vector<base::string16> options16(options_size);
  25   for (size_t i = 0; i < options_size; ++i)
  26     options16[i] = UTF8ToUTF16(options[i]);
  27
  28   FormFieldData form_field;
  29   form_field.form_control_type = "select-one";
  30   form_field.option_values = options16;
  31   form_field.option_contents = options16;
  32   return form_field;
  33 }
  34
  35 struct TestCase {
  36   std::string card_number_;
  37   size_t total_spilts_;
  38   std::vector<int> splits_;
  39   std::vector<std::string> expected_results_;
  40 };
  41
  42 // Returns the offset to be set within the credit card number field.
  43 size_t GetNumberOffset(size_t index, const TestCase& test) {
  44   size_t result = 0;
  45   for (size_t i = 0; i < index; ++i)
  46     result += test.splits_[i];
  47   return result;
  48 }
  49
  50 TEST(AutofillFieldTest, Type) {
  51   AutofillField field;
  52   ASSERT_EQ(NO_SERVER_DATA, field.server_type());
  53   ASSERT_EQ(UNKNOWN_TYPE, field.heuristic_type());
  54
  55   // |server_type_| is NO_SERVER_DATA, so |heuristic_type_| is returned.
  56   EXPECT_EQ(UNKNOWN_TYPE, field.Type().GetStorableType());
  57
  58   // Set the heuristic type and check it.
  59   field.set_heuristic_type(NAME_FIRST);
  60   EXPECT_EQ(NAME_FIRST, field.Type().GetStorableType());
  61   EXPECT_EQ(NAME, field.Type().group());
  62
  63   // Set the server type and check it.
  64   field.set_server_type(ADDRESS_BILLING_LINE1);
  65   EXPECT_EQ(ADDRESS_HOME_LINE1, field.Type().GetStorableType());
  66   EXPECT_EQ(ADDRESS_BILLING, field.Type().group());
  67
  68   // Remove the server type to make sure the heuristic type is preserved.
  69   field.set_server_type(NO_SERVER_DATA);
  70   EXPECT_EQ(NAME_FIRST, field.Type().GetStorableType());
  71   EXPECT_EQ(NAME, field.Type().group());
  72 }
  73
  74 TEST(AutofillFieldTest, IsEmpty) {
  75   AutofillField field;
  76   ASSERT_EQ(base::string16(), field.value);
  77
  78   // Field value is empty.
  79   EXPECT_TRUE(field.IsEmpty());
  80
  81   // Field value is non-empty.
  82   field.value = ASCIIToUTF16("Value");
  83   EXPECT_FALSE(field.IsEmpty());
  84 }
  85
  86 TEST(AutofillFieldTest, FieldSignature) {
  87   AutofillField field;
  88   ASSERT_EQ(base::string16(), field.name);
  89   ASSERT_EQ(std::string(), field.form_control_type);
  90
  91   // Signature is empty.
  92   EXPECT_EQ("2085434232", field.FieldSignature());
  93
  94   // Field name is set.
  95   field.name = ASCIIToUTF16("Name");
  96   EXPECT_EQ("1606968241", field.FieldSignature());
  97
  98   // Field form control type is set.
  99   field.form_control_type = "text";
 100   EXPECT_EQ("502192749", field.FieldSignature());
 101
 102   // Heuristic type does not affect FieldSignature.
 103   field.set_heuristic_type(NAME_FIRST);
 104   EXPECT_EQ("502192749", field.FieldSignature());
 105
 106   // Server type does not affect FieldSignature.
 107   field.set_server_type(NAME_LAST);
 108   EXPECT_EQ("502192749", field.FieldSignature());
 109 }
 110
 111 TEST(AutofillFieldTest, IsFieldFillable) {
 112   AutofillField field;
 113   ASSERT_EQ(UNKNOWN_TYPE, field.Type().GetStorableType());
 114
 115   // Type is unknown.
 116   EXPECT_FALSE(field.IsFieldFillable());
 117
 118   // Only heuristic type is set.
 119   field.set_heuristic_type(NAME_FIRST);
 120   EXPECT_TRUE(field.IsFieldFillable());
 121
 122   // Only server type is set.
 123   field.set_heuristic_type(UNKNOWN_TYPE);
 124   field.set_server_type(NAME_LAST);
 125   EXPECT_TRUE(field.IsFieldFillable());
 126
 127   // Both types set.
 128   field.set_heuristic_type(NAME_FIRST);
 129   field.set_server_type(NAME_LAST);
 130   EXPECT_TRUE(field.IsFieldFillable());
 131
 132   // Field has autocomplete="off" set. Chrome ignores the attribute.
 133   field.should_autocomplete = false;
 134   EXPECT_TRUE(field.IsFieldFillable());
 135 }
 136
 137 TEST(AutofillFieldTest, FillPhoneNumber) {
 138   AutofillField field;
 139   field.SetHtmlType(HTML_TYPE_TEL_LOCAL_PREFIX, HtmlFieldMode());
 140
 141   // Fill with a non-phone number; should fill normally.
 142   AutofillField::FillFormField(
 143       field, ASCIIToUTF16("Oh hai"), "en-US", "en-US", &field);
 144   EXPECT_EQ(ASCIIToUTF16("Oh hai"), field.value);
 145
 146   // Fill with a phone number; should fill just the prefix.
 147   AutofillField::FillFormField(
 148       field, ASCIIToUTF16("5551234"), "en-US", "en-US", &field);
 149   EXPECT_EQ(ASCIIToUTF16("555"), field.value);
 150
 151   // Now reset the type, and set a max-length instead.
 152   field.SetHtmlType(HTML_TYPE_UNKNOWN, HtmlFieldMode());
 153   field.set_heuristic_type(PHONE_HOME_NUMBER);
 154   field.max_length = 4;
 155
 156   // Fill with a phone-number; should fill just the suffix.
 157   AutofillField::FillFormField(
 158       field, ASCIIToUTF16("5551234"), "en-US", "en-US", &field);
 159   EXPECT_EQ(ASCIIToUTF16("1234"), field.value);
 160 }
 161
 162 TEST(AutofillFieldTest, FillSelectControlByValue) {
 163   const char* const kOptions[] = {
 164     "Eenie", "Meenie", "Miney", "Mo",
 165   };
 166   AutofillField field(
 167       GenerateSelectFieldWithOptions(kOptions, arraysize(kOptions)),
 168       base::string16());
 169
 170   // Set semantically empty contents for each option, so that only the values
 171   // can be used for matching.
 172   for (size_t i = 0; i < field.option_contents.size(); ++i)
 173     field.option_contents[i] = base::SizeTToString16(i);
 174
 175   AutofillField::FillFormField(
 176       field, ASCIIToUTF16("Meenie"), "en-US", "en-US", &field);
 177   EXPECT_EQ(ASCIIToUTF16("Meenie"), field.value);
 178 }
 179
 180 TEST(AutofillFieldTest, FillSelectControlByContents) {
 181   const char* const kOptions[] = {
 182     "Eenie", "Meenie", "Miney", "Mo",
 183   };
 184   AutofillField field(
 185       GenerateSelectFieldWithOptions(kOptions, arraysize(kOptions)),
 186       base::string16());
 187
 188   // Set semantically empty values for each option, so that only the contents
 189   // can be used for matching.
 190   for (size_t i = 0; i < field.option_values.size(); ++i)
 191     field.option_values[i] = base::SizeTToString16(i);
 192
 193   AutofillField::FillFormField(
 194       field, ASCIIToUTF16("Miney"), "en-US", "en-US", &field);
 195   EXPECT_EQ(ASCIIToUTF16("2"), field.value);  // Corresponds to "Miney".
 196 }
 197
 198 TEST(AutofillFieldTest, FillSelectControlWithFullCountryNames) {
 199   const char* const kCountries[] = {
 200     "Albania", "Canada"
 201   };
 202   AutofillField field(
 203       GenerateSelectFieldWithOptions(kCountries, arraysize(kCountries)),
 204       base::string16());
 205   field.set_heuristic_type(ADDRESS_HOME_COUNTRY);
 206
 207   AutofillField::FillFormField(
 208       field, ASCIIToUTF16("CA"), "en-US", "en-US", &field);
 209   EXPECT_EQ(ASCIIToUTF16("Canada"), field.value);
 210 }
 211
 212 TEST(AutofillFieldTest, FillSelectControlWithAbbreviatedCountryNames) {
 213   const char* const kCountries[] = {
 214     "AL", "CA"
 215   };
 216   AutofillField field(
 217       GenerateSelectFieldWithOptions(kCountries, arraysize(kCountries)),
 218       base::string16());
 219   field.set_heuristic_type(ADDRESS_HOME_COUNTRY);
 220
 221   AutofillField::FillFormField(
 222       field, ASCIIToUTF16("Canada"), "en-US", "en-US", &field);
 223   EXPECT_EQ(ASCIIToUTF16("CA"), field.value);
 224 }
 225
 226 TEST(AutofillFieldTest, FillSelectControlWithFullStateNames) {
 227   const char* const kStates[] = {
 228     "Alabama", "California"
 229   };
 230   AutofillField field(
 231       GenerateSelectFieldWithOptions(kStates, arraysize(kStates)),
 232       base::string16());
 233   field.set_heuristic_type(ADDRESS_HOME_STATE);
 234
 235   AutofillField::FillFormField(
 236       field, ASCIIToUTF16("CA"), "en-US", "en-US", &field);
 237   EXPECT_EQ(ASCIIToUTF16("California"), field.value);
 238 }
 239
 240 TEST(AutofillFieldTest, FillSelectControlWithAbbreviateStateNames) {
 241   const char* const kStates[] = {
 242     "AL", "CA"
 243   };
 244   AutofillField field(
 245       GenerateSelectFieldWithOptions(kStates, arraysize(kStates)),
 246       base::string16());
 247   field.set_heuristic_type(ADDRESS_HOME_STATE);
 248
 249   AutofillField::FillFormField(
 250       field, ASCIIToUTF16("California"), "en-US", "en-US", &field);
 251   EXPECT_EQ(ASCIIToUTF16("CA"), field.value);
 252 }
 253
 254 TEST(AutofillFieldTest, FillSelectControlWithInexactFullStateNames) {
 255   {
 256     const char* const kStates[] = {
 257       "SC - South Carolina", "CA - California", "NC - North Carolina",
 258     };
 259     AutofillField field(
 260         GenerateSelectFieldWithOptions(kStates, arraysize(kStates)),
 261         base::string16());
 262     field.set_heuristic_type(ADDRESS_HOME_STATE);
 263
 264     AutofillField::FillFormField(
 265         field, ASCIIToUTF16("California"), "en-US", "en-US", &field);
 266     EXPECT_EQ(ASCIIToUTF16("CA - California"), field.value);
 267   }
 268
 269   // Don't accidentally match "Virginia" to "West Virginia".
 270   {
 271     const char* const kStates[] = {
 272       "WV - West Virginia", "VA - Virginia", "NV - North Virginia",
 273     };
 274     AutofillField field(
 275         GenerateSelectFieldWithOptions(kStates, arraysize(kStates)),
 276         base::string16());
 277     field.set_heuristic_type(ADDRESS_HOME_STATE);
 278
 279     AutofillField::FillFormField(
 280         field, ASCIIToUTF16("Virginia"), "en-US", "en-US", &field);
 281     EXPECT_EQ(ASCIIToUTF16("VA - Virginia"), field.value);
 282   }
 283
 284   // Do accidentally match "Virginia" to "West Virginia". NB: Ideally, Chrome
 285   // would fail this test. It's here to document behavior rather than enforce
 286   // it.
 287   {
 288     const char* const kStates[] = {
 289       "WV - West Virginia", "TX - Texas",
 290     };
 291     AutofillField field(
 292         GenerateSelectFieldWithOptions(kStates, arraysize(kStates)),
 293         base::string16());
 294     field.set_heuristic_type(ADDRESS_HOME_STATE);
 295
 296     AutofillField::FillFormField(
 297         field, ASCIIToUTF16("Virginia"), "en-US", "en-US", &field);
 298     EXPECT_EQ(ASCIIToUTF16("WV - West Virginia"), field.value);
 299   }
 300
 301   // Tests that substring matches work for full state names (a full token
 302   // match isn't required). Also tests that matches work for states with
 303   // whitespace in the middle.
 304   {
 305     const char* const kStates[] = {
 306       "California.", "North Carolina.",
 307     };
 308     AutofillField field(
 309         GenerateSelectFieldWithOptions(kStates, arraysize(kStates)),
 310         base::string16());
 311     field.set_heuristic_type(ADDRESS_HOME_STATE);
 312
 313     AutofillField::FillFormField(
 314         field, ASCIIToUTF16("North Carolina"), "en-US", "en-US", &field);
 315     EXPECT_EQ(ASCIIToUTF16("North Carolina."), field.value);
 316   }
 317 }
 318
 319 TEST(AutofillFieldTest, FillSelectControlWithInexactAbbreviations) {
 320   {
 321     const char* const kStates[] = {
 322       "NC - North Carolina", "CA - California",
 323     };
 324     AutofillField field(
 325         GenerateSelectFieldWithOptions(kStates, arraysize(kStates)),
 326         base::string16());
 327     field.set_heuristic_type(ADDRESS_HOME_STATE);
 328
 329     AutofillField::FillFormField(
 330         field, ASCIIToUTF16("CA"), "en-US", "en-US", &field);
 331     EXPECT_EQ(ASCIIToUTF16("CA - California"), field.value);
 332   }
 333
 334   {
 335     const char* const kNotStates[] = {
 336       "NCNCA", "SCNCA",
 337     };
 338     AutofillField field(
 339         GenerateSelectFieldWithOptions(kNotStates, arraysize(kNotStates)),
 340         base::string16());
 341     field.set_heuristic_type(ADDRESS_HOME_STATE);
 342
 343     AutofillField::FillFormField(
 344         field, ASCIIToUTF16("NC"), "en-US", "en-US", &field);
 345     EXPECT_EQ(base::string16(), field.value);
 346   }
 347 }
 348
 349 TEST(AutofillFieldTest, FillSelectControlWithNumericMonth) {
 350   const char* const kMonthsNumeric[] = {
 351     "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12",
 352   };
 353   AutofillField field(
 354       GenerateSelectFieldWithOptions(kMonthsNumeric, arraysize(kMonthsNumeric)),
 355       base::string16());
 356   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 357
 358   // Try with a leading zero.
 359   AutofillField::FillFormField(
 360       field, ASCIIToUTF16("03"), "en-US", "en-US", &field);
 361   EXPECT_EQ(ASCIIToUTF16("03"), field.value);
 362
 363   // Try without a leading zero.
 364   AutofillField::FillFormField(
 365       field, ASCIIToUTF16("4"), "en-US", "en-US", &field);
 366   EXPECT_EQ(ASCIIToUTF16("04"), field.value);
 367
 368   // Try a two-digit month.
 369   AutofillField::FillFormField(
 370       field, ASCIIToUTF16("11"), "en-US", "en-US", &field);
 371   EXPECT_EQ(ASCIIToUTF16("11"), field.value);
 372 }
 373
 374 TEST(AutofillFieldTest, FillSelectControlWithAbbreviatedMonthName) {
 375   const char* const kMonthsAbbreviated[] = {
 376     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 377     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
 378   };
 379   AutofillField field(
 380       GenerateSelectFieldWithOptions(
 381           kMonthsAbbreviated, arraysize(kMonthsAbbreviated)),
 382       base::string16());
 383   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 384
 385   AutofillField::FillFormField(
 386       field, ASCIIToUTF16("04"), "en-US", "en-US", &field);
 387   EXPECT_EQ(ASCIIToUTF16("Apr"), field.value);
 388 }
 389
 390 TEST(AutofillFieldTest, FillSelectControlWithFullMonthName) {
 391   const char* const kMonthsFull[] = {
 392     "January", "February", "March", "April", "May", "June",
 393     "July", "August", "September", "October", "November", "December",
 394   };
 395   AutofillField field(
 396       GenerateSelectFieldWithOptions(kMonthsFull, arraysize(kMonthsFull)),
 397       base::string16());
 398   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 399
 400   AutofillField::FillFormField(
 401       field, ASCIIToUTF16("04"), "en-US", "en-US", &field);
 402   EXPECT_EQ(ASCIIToUTF16("April"), field.value);
 403 }
 404
 405 TEST(AutofillFieldTest, FillSelectControlWithFrenchMonthName) {
 406   const char* const kMonthsFrench[] = {
 407     "JANV", "FÉVR.", "MARS", "décembre"
 408   };
 409   AutofillField field(
 410       GenerateSelectFieldWithOptions(kMonthsFrench, arraysize(kMonthsFrench)),
 411       base::string16());
 412   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 413
 414   AutofillField::FillFormField(
 415       field, ASCIIToUTF16("02"), "fr-FR", "fr-FR", &field);
 416   EXPECT_EQ(UTF8ToUTF16("FÉVR."), field.value);
 417
 418   AutofillField::FillFormField(
 419       field, ASCIIToUTF16("01"), "fr-FR", "fr-FR", &field);
 420   EXPECT_EQ(UTF8ToUTF16("JANV"), field.value);
 421
 422   AutofillField::FillFormField(
 423       field, ASCIIToUTF16("12"), "fr-FR", "fr-FR", &field);
 424   EXPECT_EQ(UTF8ToUTF16("décembre"), field.value);
 425 }
 426
 427 TEST(AutofillFieldTest, FillSelectControlWithNumericMonthSansLeadingZero) {
 428   const char* const kMonthsNumeric[] = {
 429     "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
 430   };
 431   AutofillField field(
 432       GenerateSelectFieldWithOptions(kMonthsNumeric, arraysize(kMonthsNumeric)),
 433       base::string16());
 434   field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
 435
 436   AutofillField::FillFormField(
 437       field, ASCIIToUTF16("04"), "en-US", "en-US", &field);
 438   EXPECT_EQ(ASCIIToUTF16("4"), field.value);
 439 }
 440
 441 TEST(AutofillFieldTest, FillSelectControlWithTwoDigitCreditCardYear) {
 442   const char* const kYears[] = {
 443     "12", "13", "14", "15", "16", "17", "18", "19"
 444   };
 445   AutofillField field(GenerateSelectFieldWithOptions(kYears, arraysize(kYears)),
 446                       base::string16());
 447   field.set_heuristic_type(CREDIT_CARD_EXP_2_DIGIT_YEAR);
 448
 449   AutofillField::FillFormField(
 450       field, ASCIIToUTF16("2017"), "en-US", "en-US", &field);
 451   EXPECT_EQ(ASCIIToUTF16("17"), field.value);
 452 }
 453
 454 TEST(AutofillFieldTest, FillSelectControlWithCreditCardType) {
 455   const char* const kCreditCardTypes[] = {
 456     "Visa", "Master Card", "AmEx", "discover"
 457   };
 458   AutofillField field(
 459       GenerateSelectFieldWithOptions(
 460           kCreditCardTypes, arraysize(kCreditCardTypes)),
 461       base::string16());
 462   field.set_heuristic_type(CREDIT_CARD_TYPE);
 463
 464   // Normal case:
 465   AutofillField::FillFormField(
 466       field, ASCIIToUTF16("Visa"), "en-US", "en-US", &field);
 467   EXPECT_EQ(ASCIIToUTF16("Visa"), field.value);
 468
 469   // Filling should be able to handle intervening whitespace:
 470   AutofillField::FillFormField(
 471       field, ASCIIToUTF16("MasterCard"), "en-US", "en-US", &field);
 472   EXPECT_EQ(ASCIIToUTF16("Master Card"), field.value);
 473
 474   // American Express is sometimes abbreviated as AmEx:
 475   AutofillField::FillFormField(
 476       field, ASCIIToUTF16("American Express"), "en-US", "en-US", &field);
 477   EXPECT_EQ(ASCIIToUTF16("AmEx"), field.value);
 478
 479   // Case insensitivity:
 480   AutofillField::FillFormField(
 481       field, ASCIIToUTF16("Discover"), "en-US", "en-US", &field);
 482   EXPECT_EQ(ASCIIToUTF16("discover"), field.value);
 483 }
 484
 485 TEST(AutofillFieldTest, FillMonthControl) {
 486   AutofillField field;
 487   field.form_control_type = "month";
 488
 489   // Try a month with two digits.
 490   AutofillField::FillFormField(
 491       field, ASCIIToUTF16("12/2017"), "en-US", "en-US", &field);
 492   EXPECT_EQ(ASCIIToUTF16("2017-12"), field.value);
 493
 494   // Try a month with a leading zero.
 495   AutofillField::FillFormField(
 496       field, ASCIIToUTF16("03/2019"), "en-US", "en-US", &field);
 497   EXPECT_EQ(ASCIIToUTF16("2019-03"), field.value);
 498
 499   // Try a month without a leading zero.
 500   AutofillField::FillFormField(
 501       field, ASCIIToUTF16("4/2018"), "en-US", "en-US", &field);
 502   EXPECT_EQ(ASCIIToUTF16("2018-04"), field.value);
 503 }
 504
 505 TEST(AutofillFieldTest, FillStreetAddressTextArea) {
 506   AutofillField field;
 507   field.form_control_type = "textarea";
 508
 509   base::string16 value = ASCIIToUTF16("123 Fake St.\n"
 510                                       "Apt. 42");
 511   AutofillField::FillFormField(field, value, "en-US", "en-US", &field);
 512   EXPECT_EQ(value, field.value);
 513
 514   base::string16 ja_value = UTF8ToUTF16("桜丘町26-1\n"
 515                                         "セルリアンタワー6階");
 516   AutofillField::FillFormField(field, ja_value, "ja-JP", "en-US", &field);
 517   EXPECT_EQ(ja_value, field.value);
 518 }
 519
 520 TEST(AutofillFieldTest, FillStreetAddressTextField) {
 521   AutofillField field;
 522   field.form_control_type = "text";
 523   field.set_server_type(ADDRESS_HOME_STREET_ADDRESS);
 524
 525   base::string16 value = ASCIIToUTF16("123 Fake St.\n"
 526                                       "Apt. 42");
 527   AutofillField::FillFormField(field, value, "en-US", "en-US", &field);
 528   EXPECT_EQ(ASCIIToUTF16("123 Fake St., Apt. 42"), field.value);
 529
 530   AutofillField::FillFormField(field,
 531                                UTF8ToUTF16("桜丘町26-1\n"
 532                                            "セルリアンタワー6階"),
 533                                "ja-JP",
 534                                "en-US",
 535                                &field);
 536   EXPECT_EQ(UTF8ToUTF16("桜丘町26-1セルリアンタワー6階"), field.value);
 537 }
 538
 539 TEST(AutofillFieldTest, FillCreditCardNumberWithoutSplits) {
 540   // Case 1: card number without any spilt.
 541   AutofillField cc_number_full;
 542   cc_number_full.set_heuristic_type(CREDIT_CARD_NUMBER);
 543   AutofillField::FillFormField(cc_number_full,
 544                                ASCIIToUTF16("4111111111111111"),
 545                                "en-US",
 546                                "en-US",
 547                                &cc_number_full);
 548
 549   // Verify that full card-number shall get fill properly.
 550   EXPECT_EQ(ASCIIToUTF16("4111111111111111"), cc_number_full.value);
 551   EXPECT_EQ(0U, cc_number_full.credit_card_number_offset());
 552 }
 553
 554 TEST(AutofillFieldTest, FillCreditCardNumberWithEqualSizeSplits) {
 555   // Case 2: card number broken up into four equal groups, of length 4.
 556   TestCase test;
 557   test.card_number_ = "5187654321098765";
 558   test.total_spilts_ = 4;
 559   int splits[] = {4, 4, 4, 4};
 560   test.splits_ = std::vector<int>(splits, splits + arraysize(splits));
 561   std::string results[] = {"5187", "6543", "2109", "8765"};
 562   test.expected_results_ =
 563       std::vector<std::string>(results, results + arraysize(results));
 564
 565   for (size_t i = 0; i < test.total_spilts_; ++i) {
 566     AutofillField cc_number_part;
 567     cc_number_part.set_heuristic_type(CREDIT_CARD_NUMBER);
 568     cc_number_part.max_length = test.splits_[i];
 569     cc_number_part.set_credit_card_number_offset(4 * i);
 570
 571     // Fill with a card-number; should fill just the card_number_part.
 572     AutofillField::FillFormField(cc_number_part,
 573                                  ASCIIToUTF16(test.card_number_),
 574                                  "en-US",
 575                                  "en-US",
 576                                  &cc_number_part);
 577
 578     // Verify for expected results.
 579     EXPECT_EQ(ASCIIToUTF16(test.expected_results_[i]),
 580               cc_number_part.value.substr(0, cc_number_part.max_length));
 581     EXPECT_EQ(4 * i, cc_number_part.credit_card_number_offset());
 582   }
 583
 584   // Verify that full card-number shall get fill properly as well.
 585   AutofillField cc_number_full;
 586   cc_number_full.set_heuristic_type(CREDIT_CARD_NUMBER);
 587   AutofillField::FillFormField(cc_number_full,
 588                                ASCIIToUTF16(test.card_number_),
 589                                "en-US",
 590                                "en-US",
 591                                &cc_number_full);
 592
 593   // Verify for expected results.
 594   EXPECT_EQ(ASCIIToUTF16(test.card_number_), cc_number_full.value);
 595 }
 596
 597 TEST(AutofillFieldTest, FillCreditCardNumberWithUnequalSizeSplits) {
 598   // Case 3: card with 15 digits number, broken up into three unequal groups, of
 599   // lengths 4, 6, and 5.
 600   TestCase test;
 601   test.card_number_ = "423456789012345";
 602   test.total_spilts_ = 3;
 603   int splits[] = {4, 6, 5};
 604   test.splits_ = std::vector<int>(splits, splits + arraysize(splits));
 605   std::string results[] = {"4234", "567890", "12345"};
 606   test.expected_results_ =
 607       std::vector<std::string>(results, results + arraysize(results));
 608
 609   // Start executing test cases to verify parts and full credit card number.
 610   for (size_t i = 0; i < test.total_spilts_; ++i) {
 611     AutofillField cc_number_part;
 612     cc_number_part.set_heuristic_type(CREDIT_CARD_NUMBER);
 613     cc_number_part.max_length = test.splits_[i];
 614     cc_number_part.set_credit_card_number_offset(GetNumberOffset(i, test));
 615
 616     // Fill with a card-number; should fill just the card_number_part.
 617     AutofillField::FillFormField(cc_number_part,
 618                                  ASCIIToUTF16(test.card_number_),
 619                                  "en-US",
 620                                  "en-US",
 621                                  &cc_number_part);
 622
 623     // Verify for expected results.
 624     EXPECT_EQ(ASCIIToUTF16(test.expected_results_[i]),
 625               cc_number_part.value.substr(0, cc_number_part.max_length));
 626     EXPECT_EQ(GetNumberOffset(i, test),
 627               cc_number_part.credit_card_number_offset());
 628   }
 629
 630   // Verify that full card-number shall get fill properly as well.
 631   AutofillField cc_number_full;
 632   cc_number_full.set_heuristic_type(CREDIT_CARD_NUMBER);
 633   AutofillField::FillFormField(cc_number_full,
 634                                ASCIIToUTF16(test.card_number_),
 635                                "en-US",
 636                                "en-US",
 637                                &cc_number_full);
 638
 639   // Verify for expected results.
 640   EXPECT_EQ(ASCIIToUTF16(test.card_number_), cc_number_full.value);
 641 }
 642
 643 TEST(AutofillFieldTest, FindValueInSelectControl) {
 644   const size_t kBadIndex = 1000;
 645
 646   {
 647     const char* const kCountries[] = {
 648       "Albania", "Canada"
 649     };
 650     FormFieldData field(
 651         GenerateSelectFieldWithOptions(kCountries, arraysize(kCountries)));
 652     size_t index = kBadIndex;
 653     bool ret = AutofillField::FindValueInSelectControl(
 654         field, ASCIIToUTF16("Canada"), &index);
 655     EXPECT_TRUE(ret);
 656     EXPECT_EQ(1U, index);
 657
 658     index = kBadIndex;
 659     ret = AutofillField::FindValueInSelectControl(
 660         field, ASCIIToUTF16("CANADA"), &index);
 661     EXPECT_TRUE(ret);
 662     EXPECT_EQ(1U, index);
 663
 664     index = kBadIndex;
 665     ret = AutofillField::FindValueInSelectControl(
 666         field, ASCIIToUTF16("Canadia"), &index);
 667     EXPECT_FALSE(ret);
 668     EXPECT_EQ(kBadIndex, index);
 669   }
 670
 671   {
 672     const char* const kProvinces[] = {
 673       "ALBERTA", "QUÉBEC", "NOVA SCOTIA",
 674     };
 675     FormFieldData field(
 676         GenerateSelectFieldWithOptions(kProvinces, arraysize(kProvinces)));
 677     size_t index = kBadIndex;
 678     bool ret = AutofillField::FindValueInSelectControl(
 679         field, ASCIIToUTF16("alberta"), &index);
 680     EXPECT_TRUE(ret);
 681     EXPECT_EQ(0U, index);
 682
 683     index = kBadIndex;
 684     ret = AutofillField::FindValueInSelectControl(
 685         field, UTF8ToUTF16("québec"), &index);
 686     EXPECT_TRUE(ret);
 687     EXPECT_EQ(1U, index);
 688
 689     index = kBadIndex;
 690     ret = AutofillField::FindValueInSelectControl(
 691         field, UTF8ToUTF16("NoVaScOtIa"), &index);
 692     EXPECT_TRUE(ret);
 693     EXPECT_EQ(2U, index);
 694   }
 695 }
 696
 697 }  // namespace
 698 }  // namespace autofill