src/components/autofill/core/browser/credit_card_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 "base/basictypes.h"
   6 #include "base/guid.h"
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "components/autofill/core/browser/autofill_test_utils.h"
   9 #include "components/autofill/core/browser/autofill_type.h"
  10 #include "components/autofill/core/browser/credit_card.h"
  11 #include "components/autofill/core/browser/validation.h"
  12 #include "components/autofill/core/common/form_field_data.h"
  13 #include "grit/components_scaled_resources.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 using base::ASCIIToUTF16;
  17
  18 namespace autofill {
  19 namespace {
  20
  21 // From https://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_numbers.htm
  22 const char* const kValidNumbers[] = {
  23   "378282246310005",
  24   "3714 4963 5398 431",
  25   "3787-3449-3671-000",
  26   "5610591081018250",
  27   "3056 9309 0259 04",
  28   "3852-0000-0232-37",
  29   "6011111111111117",
  30   "6011 0009 9013 9424",
  31   "3530-1113-3330-0000",
  32   "3566002020360505",
  33   "5555 5555 5555 4444",
  34   "5105-1051-0510-5100",
  35   "4111111111111111",
  36   "4012 8888 8888 1881",
  37   "4222-2222-2222-2",
  38   "5019717010103742",
  39   "6331101999990016",
  40
  41   // A UnionPay card that doesn't pass the Luhn checksum
  42   "6200000000000000",
  43 };
  44 const char* const kInvalidNumbers[] = {
  45   "4111 1111 112", /* too short */
  46   "41111111111111111115", /* too long */
  47   "4111-1111-1111-1110", /* wrong Luhn checksum */
  48   "3056 9309 0259 04aa", /* non-digit characters */
  49 };
  50
  51 }  // namespace
  52
  53 // Tests credit card summary string generation.  This test simulates a variety
  54 // of different possible summary strings.  Variations occur based on the
  55 // existence of credit card number, month, and year fields.
  56 TEST(CreditCardTest, PreviewSummaryAndObfuscatedNumberStrings) {
  57   // Case 0: empty credit card.
  58   CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com/");
  59   base::string16 summary0 = credit_card0.Label();
  60   EXPECT_EQ(base::string16(), summary0);
  61   base::string16 obfuscated0 = credit_card0.ObfuscatedNumber();
  62   EXPECT_EQ(base::string16(), obfuscated0);
  63
  64   // Case 00: Empty credit card with empty strings.
  65   CreditCard credit_card00(base::GenerateGUID(), "https://www.example.com/");
  66   test::SetCreditCardInfo(&credit_card00,"John Dillinger", "", "", "");
  67   base::string16 summary00 = credit_card00.Label();
  68   EXPECT_EQ(base::string16(ASCIIToUTF16("John Dillinger")), summary00);
  69   base::string16 obfuscated00 = credit_card00.ObfuscatedNumber();
  70   EXPECT_EQ(base::string16(), obfuscated00);
  71
  72   // Case 1: No credit card number.
  73   CreditCard credit_card1(base::GenerateGUID(), "https://www.example.com/");
  74   test::SetCreditCardInfo(&credit_card1,"John Dillinger", "", "01", "2010");
  75   base::string16 summary1 = credit_card1.Label();
  76   EXPECT_EQ(base::string16(ASCIIToUTF16("John Dillinger")), summary1);
  77   base::string16 obfuscated1 = credit_card1.ObfuscatedNumber();
  78   EXPECT_EQ(base::string16(), obfuscated1);
  79
  80   // Case 2: No month.
  81   CreditCard credit_card2(base::GenerateGUID(), "https://www.example.com/");
  82   test::SetCreditCardInfo(
  83       &credit_card2, "John Dillinger", "5105 1051 0510 5100", "", "2010");
  84   base::string16 summary2 = credit_card2.Label();
  85   EXPECT_EQ(ASCIIToUTF16("************5100"), summary2);
  86   base::string16 obfuscated2 = credit_card2.ObfuscatedNumber();
  87   EXPECT_EQ(ASCIIToUTF16("************5100"), obfuscated2);
  88
  89   // Case 3: No year.
  90   CreditCard credit_card3(base::GenerateGUID(), "https://www.example.com/");
  91   test::SetCreditCardInfo(
  92       &credit_card3, "John Dillinger", "5105 1051 0510 5100", "01", "");
  93   base::string16 summary3 = credit_card3.Label();
  94   EXPECT_EQ(ASCIIToUTF16("************5100"), summary3);
  95   base::string16 obfuscated3 = credit_card3.ObfuscatedNumber();
  96   EXPECT_EQ(ASCIIToUTF16("************5100"), obfuscated3);
  97
  98   // Case 4: Have everything.
  99   CreditCard credit_card4(base::GenerateGUID(), "https://www.example.com/");
 100   test::SetCreditCardInfo(
 101       &credit_card4, "John Dillinger", "5105 1051 0510 5100", "01", "2010");
 102   base::string16 summary4 = credit_card4.Label();
 103   EXPECT_EQ(ASCIIToUTF16("************5100, Exp: 01/2010"), summary4);
 104   base::string16 obfuscated4 = credit_card4.ObfuscatedNumber();
 105   EXPECT_EQ(ASCIIToUTF16("************5100"), obfuscated4);
 106
 107   // Case 5: Very long credit card
 108   CreditCard credit_card5(base::GenerateGUID(), "https://www.example.com/");
 109   test::SetCreditCardInfo(
 110       &credit_card5,
 111       "John Dillinger",
 112       "0123456789 0123456789 0123456789 5105 1051 0510 5100", "01", "2010");
 113   base::string16 summary5 = credit_card5.Label();
 114   EXPECT_EQ(ASCIIToUTF16("********************5100, Exp: 01/2010"), summary5);
 115   base::string16 obfuscated5 = credit_card5.ObfuscatedNumber();
 116   EXPECT_EQ(ASCIIToUTF16("********************5100"), obfuscated5);
 117 }
 118
 119 TEST(CreditCardTest, AssignmentOperator) {
 120   CreditCard a(base::GenerateGUID(), "some origin");
 121   test::SetCreditCardInfo(&a, "John Dillinger", "123456789012", "01", "2010");
 122
 123   // Result of assignment should be logically equal to the original profile.
 124   CreditCard b(base::GenerateGUID(), "some other origin");
 125   b = a;
 126   EXPECT_TRUE(a == b);
 127
 128   // Assignment to self should not change the profile value.
 129   a = a;
 130   EXPECT_TRUE(a == b);
 131 }
 132
 133 TEST(CreditCardTest, Copy) {
 134   CreditCard a(base::GenerateGUID(), "https://www.example.com");
 135   test::SetCreditCardInfo(&a, "John Dillinger", "123456789012", "01", "2010");
 136
 137   // Clone should be logically equal to the original.
 138   CreditCard b(a);
 139   EXPECT_TRUE(a == b);
 140 }
 141
 142 TEST(CreditCardTest, Compare) {
 143   CreditCard a(base::GenerateGUID(), std::string());
 144   CreditCard b(base::GenerateGUID(), std::string());
 145
 146   // Empty cards are the same.
 147   EXPECT_EQ(0, a.Compare(b));
 148
 149   // GUIDs don't count.
 150   a.set_guid(base::GenerateGUID());
 151   b.set_guid(base::GenerateGUID());
 152   EXPECT_EQ(0, a.Compare(b));
 153
 154   // Origins don't count.
 155   a.set_origin("apple");
 156   b.set_origin("banana");
 157   EXPECT_EQ(0, a.Compare(b));
 158
 159   // Different values produce non-zero results.
 160   test::SetCreditCardInfo(&a, "Jimmy", NULL, NULL, NULL);
 161   test::SetCreditCardInfo(&b, "Ringo", NULL, NULL, NULL);
 162   EXPECT_GT(0, a.Compare(b));
 163   EXPECT_LT(0, b.Compare(a));
 164 }
 165
 166 // Test we get the correct icon for each card type.
 167 TEST(CreditCardTest, IconResourceId) {
 168   EXPECT_EQ(IDR_AUTOFILL_CC_AMEX,
 169             CreditCard::IconResourceId(kAmericanExpressCard));
 170   EXPECT_EQ(IDR_AUTOFILL_CC_DINERS,
 171             CreditCard::IconResourceId(kDinersCard));
 172   EXPECT_EQ(IDR_AUTOFILL_CC_DISCOVER,
 173             CreditCard::IconResourceId(kDiscoverCard));
 174   EXPECT_EQ(IDR_AUTOFILL_CC_JCB,
 175             CreditCard::IconResourceId(kJCBCard));
 176   EXPECT_EQ(IDR_AUTOFILL_CC_MASTERCARD,
 177             CreditCard::IconResourceId(kMasterCard));
 178   EXPECT_EQ(IDR_AUTOFILL_CC_VISA,
 179             CreditCard::IconResourceId(kVisaCard));
 180 }
 181
 182 TEST(CreditCardTest, UpdateFromImportedCard) {
 183   CreditCard original_card(base::GenerateGUID(), "https://www.example.com");
 184   test::SetCreditCardInfo(
 185       &original_card, "John Dillinger", "123456789012", "09", "2017");
 186
 187   CreditCard a = original_card;
 188
 189   // The new card has a different name, expiration date, and origin.
 190   CreditCard b = a;
 191   b.set_guid(base::GenerateGUID());
 192   b.set_origin("https://www.example.org");
 193   b.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("J. Dillinger"));
 194   b.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("08"));
 195   b.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2019"));
 196
 197   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 198   EXPECT_EQ("https://www.example.org", a.origin());
 199   EXPECT_EQ(ASCIIToUTF16("J. Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 200   EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 201   EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 202
 203   // Try again, but with no name set for |b|.
 204   a = original_card;
 205   b.SetRawInfo(CREDIT_CARD_NAME, base::string16());
 206
 207   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 208   EXPECT_EQ("https://www.example.org", a.origin());
 209   EXPECT_EQ(ASCIIToUTF16("John Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 210   EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 211   EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 212
 213   // Try again, but with only the original card having a verified origin.
 214   // |a| should be unchanged.
 215   a = original_card;
 216   a.set_origin("Chrome settings");
 217   b.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("J. Dillinger"));
 218
 219   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 220   EXPECT_EQ("Chrome settings", a.origin());
 221   EXPECT_EQ(ASCIIToUTF16("John Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 222   EXPECT_EQ(ASCIIToUTF16("09"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 223   EXPECT_EQ(ASCIIToUTF16("2017"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 224
 225   // Try again, but with only the new card having a verified origin.
 226   a = original_card;
 227   b.set_origin("Chrome settings");
 228
 229   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 230   EXPECT_EQ("Chrome settings", a.origin());
 231   EXPECT_EQ(ASCIIToUTF16("J. Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 232   EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 233   EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 234
 235   // Try again, with both cards having a verified origin.
 236   a = original_card;
 237   a.set_origin("Chrome Autofill dialog");
 238   b.set_origin("Chrome settings");
 239
 240   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 241   EXPECT_EQ("Chrome settings", a.origin());
 242   EXPECT_EQ(ASCIIToUTF16("J. Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 243   EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 244   EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 245
 246   // Try again, but with |b| having a different card number.
 247   // |a| should be unchanged.
 248   a = original_card;
 249   b.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111111111111111"));
 250
 251   EXPECT_FALSE(a.UpdateFromImportedCard(b, "en-US"));
 252   EXPECT_EQ(original_card, a);
 253 }
 254
 255 TEST(CreditCardTest, IsComplete) {
 256   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 257   EXPECT_FALSE(card.IsComplete());
 258   card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Wally T. Walrus"));
 259   EXPECT_FALSE(card.IsComplete());
 260   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01"));
 261   EXPECT_FALSE(card.IsComplete());
 262   card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2014"));
 263
 264   for (size_t i = 0; i < arraysize(kValidNumbers); ++i) {
 265     SCOPED_TRACE(kValidNumbers[i]);
 266     card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(kValidNumbers[i]));
 267     EXPECT_TRUE(card.IsComplete());
 268   }
 269   for (size_t i = 0; i < arraysize(kInvalidNumbers); ++i) {
 270     SCOPED_TRACE(kInvalidNumbers[i]);
 271     card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(kInvalidNumbers[i]));
 272     EXPECT_FALSE(card.IsComplete());
 273   }
 274 }
 275
 276 TEST(CreditCardTest, IsValid) {
 277   CreditCard card;
 278   // Invalid because expired
 279   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("1"));
 280   card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2010"));
 281   card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111111111111111"));
 282   EXPECT_FALSE(card.IsValid());
 283
 284   // Invalid because card number is not complete
 285   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("12"));
 286   card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("9999"));
 287   card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("41111"));
 288   EXPECT_FALSE(card.IsValid());
 289
 290   // Valid
 291   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("12"));
 292   card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("9999"));
 293   card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111111111111111"));
 294   EXPECT_TRUE(card.IsValid());
 295 }
 296
 297 TEST(CreditCardTest, InvalidMastercardNumber) {
 298   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 299
 300   test::SetCreditCardInfo(&card, "Baby Face Nelson",
 301                           "5200000000000004", "01", "2010");
 302   EXPECT_EQ(kMasterCard, card.type());
 303   EXPECT_FALSE(card.IsComplete());
 304 }
 305
 306 // Verify that we preserve exactly what the user typed for credit card numbers.
 307 TEST(CreditCardTest, SetRawInfoCreditCardNumber) {
 308   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 309
 310   test::SetCreditCardInfo(&card, "Bob Dylan",
 311                           "4321-5432-6543-xxxx", "07", "2013");
 312   EXPECT_EQ(ASCIIToUTF16("4321-5432-6543-xxxx"),
 313             card.GetRawInfo(CREDIT_CARD_NUMBER));
 314 }
 315
 316 // Verify that we can handle both numeric and named months.
 317 TEST(CreditCardTest, SetExpirationMonth) {
 318   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 319
 320   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("05"));
 321   EXPECT_EQ(ASCIIToUTF16("05"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 322   EXPECT_EQ(5, card.expiration_month());
 323
 324   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("7"));
 325   EXPECT_EQ(ASCIIToUTF16("07"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 326   EXPECT_EQ(7, card.expiration_month());
 327
 328   // This should fail, and preserve the previous value.
 329   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("January"));
 330   EXPECT_EQ(ASCIIToUTF16("07"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 331   EXPECT_EQ(7, card.expiration_month());
 332
 333   card.SetInfo(
 334       AutofillType(CREDIT_CARD_EXP_MONTH), ASCIIToUTF16("January"), "en-US");
 335   EXPECT_EQ(ASCIIToUTF16("01"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 336   EXPECT_EQ(1, card.expiration_month());
 337
 338   card.SetInfo(
 339       AutofillType(CREDIT_CARD_EXP_MONTH), ASCIIToUTF16("Apr"), "en-US");
 340   EXPECT_EQ(ASCIIToUTF16("04"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 341   EXPECT_EQ(4, card.expiration_month());
 342 }
 343
 344 TEST(CreditCardTest, CreditCardType) {
 345   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 346
 347   // The card type cannot be set directly.
 348   card.SetRawInfo(CREDIT_CARD_TYPE, ASCIIToUTF16("Visa"));
 349   EXPECT_EQ(base::string16(), card.GetRawInfo(CREDIT_CARD_TYPE));
 350
 351   // Setting the number should implicitly set the type.
 352   card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111 1111 1111 1111"));
 353   EXPECT_EQ(ASCIIToUTF16("Visa"), card.GetRawInfo(CREDIT_CARD_TYPE));
 354 }
 355
 356 TEST(CreditCardTest, CreditCardVerificationCode) {
 357   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 358
 359   // The verification code cannot be set, as Chrome does not store this data.
 360   card.SetRawInfo(CREDIT_CARD_VERIFICATION_CODE, ASCIIToUTF16("999"));
 361   EXPECT_EQ(base::string16(), card.GetRawInfo(CREDIT_CARD_VERIFICATION_CODE));
 362 }
 363
 364
 365 TEST(CreditCardTest, GetCreditCardType) {
 366   struct {
 367     std::string card_number;
 368     std::string type;
 369     bool is_valid;
 370   } test_cases[] = {
 371     // The relevant sample numbers from
 372     // http://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_numbers.htm
 373     { "378282246310005", kAmericanExpressCard, true },
 374     { "371449635398431", kAmericanExpressCard, true },
 375     { "378734493671000", kAmericanExpressCard, true },
 376     { "30569309025904", kDinersCard, true },
 377     { "38520000023237", kDinersCard, true },
 378     { "6011111111111117", kDiscoverCard, true },
 379     { "6011000990139424", kDiscoverCard, true },
 380     { "3530111333300000", kJCBCard, true },
 381     { "3566002020360505", kJCBCard, true },
 382     { "5555555555554444", kMasterCard, true },
 383     { "5105105105105100", kMasterCard, true },
 384     { "4111111111111111", kVisaCard, true },
 385     { "4012888888881881", kVisaCard, true },
 386     { "4222222222222", kVisaCard, true },
 387
 388     // The relevant sample numbers from
 389     // http://auricsystems.com/support-center/sample-credit-card-numbers/
 390     { "343434343434343", kAmericanExpressCard, true },
 391     { "371144371144376", kAmericanExpressCard, true },
 392     { "341134113411347", kAmericanExpressCard, true },
 393     { "36438936438936", kDinersCard, true },
 394     { "36110361103612", kDinersCard, true },
 395     { "36111111111111", kDinersCard, true },
 396     { "6011016011016011", kDiscoverCard, true },
 397     { "6011000990139424", kDiscoverCard, true },
 398     { "6011000000000004", kDiscoverCard, true },
 399     { "6011000995500000", kDiscoverCard, true },
 400     { "6500000000000002", kDiscoverCard, true },
 401     { "3566002020360505", kJCBCard, true },
 402     { "3528000000000007", kJCBCard, true },
 403     { "5500005555555559", kMasterCard, true },
 404     { "5555555555555557", kMasterCard, true },
 405     { "5454545454545454", kMasterCard, true },
 406     { "5555515555555551", kMasterCard, true },
 407     { "5405222222222226", kMasterCard, true },
 408     { "5478050000000007", kMasterCard, true },
 409     { "5111005111051128", kMasterCard, true },
 410     { "5112345112345114", kMasterCard, true },
 411     { "5115915115915118", kMasterCard, true },
 412
 413     // A UnionPay card that doesn't pass the Luhn checksum
 414     { "6200000000000000", kUnionPay, true },
 415
 416     // Empty string
 417     { std::string(), kGenericCard, false },
 418
 419     // Non-numeric
 420     { "garbage", kGenericCard, false },
 421     { "4garbage", kVisaCard, false },
 422
 423     // Fails Luhn check.
 424     { "4111111111111112", kVisaCard, false },
 425
 426     // Invalid length.
 427     { "3434343434343434", kAmericanExpressCard, false },
 428     { "411111111111116", kVisaCard, false },
 429
 430     // Issuer Identification Numbers (IINs) that Chrome recognizes.
 431     { "4", kVisaCard, false },
 432     { "34", kAmericanExpressCard, false },
 433     { "37", kAmericanExpressCard, false },
 434     { "300", kDinersCard, false },
 435     { "301", kDinersCard, false },
 436     { "302", kDinersCard, false },
 437     { "303", kDinersCard, false },
 438     { "304", kDinersCard, false },
 439     { "305", kDinersCard, false },
 440     { "3095", kDinersCard, false },
 441     { "36", kDinersCard, false },
 442     { "38", kDinersCard, false },
 443     { "39", kDinersCard, false },
 444     { "6011", kDiscoverCard, false },
 445     { "644", kDiscoverCard, false },
 446     { "645", kDiscoverCard, false },
 447     { "646", kDiscoverCard, false },
 448     { "647", kDiscoverCard, false },
 449     { "648", kDiscoverCard, false },
 450     { "649", kDiscoverCard, false },
 451     { "65", kDiscoverCard, false },
 452     { "3528", kJCBCard, false },
 453     { "3531", kJCBCard, false },
 454     { "3589", kJCBCard, false },
 455     { "51", kMasterCard, false },
 456     { "52", kMasterCard, false },
 457     { "53", kMasterCard, false },
 458     { "54", kMasterCard, false },
 459     { "55", kMasterCard, false },
 460     { "62", kUnionPay, false },
 461
 462     // Not enough data to determine an IIN uniquely.
 463     { "3", kGenericCard, false },
 464     { "30", kGenericCard, false },
 465     { "309", kGenericCard, false },
 466     { "35", kGenericCard, false },
 467     { "5", kGenericCard, false },
 468     { "6", kGenericCard, false },
 469     { "60", kGenericCard, false },
 470     { "601", kGenericCard, false },
 471     { "64", kGenericCard, false },
 472
 473     // Unknown IINs.
 474     { "0", kGenericCard, false },
 475     { "1", kGenericCard, false },
 476     { "2", kGenericCard, false },
 477     { "306", kGenericCard, false },
 478     { "307", kGenericCard, false },
 479     { "308", kGenericCard, false },
 480     { "3091", kGenericCard, false },
 481     { "3094", kGenericCard, false },
 482     { "3096", kGenericCard, false },
 483     { "31", kGenericCard, false },
 484     { "32", kGenericCard, false },
 485     { "33", kGenericCard, false },
 486     { "351", kGenericCard, false },
 487     { "3527", kGenericCard, false },
 488     { "359", kGenericCard, false },
 489     { "50", kGenericCard, false },
 490     { "56", kGenericCard, false },
 491     { "57", kGenericCard, false },
 492     { "58", kGenericCard, false },
 493     { "59", kGenericCard, false },
 494     { "600", kGenericCard, false },
 495     { "602", kGenericCard, false },
 496     { "603", kGenericCard, false },
 497     { "604", kGenericCard, false },
 498     { "605", kGenericCard, false },
 499     { "606", kGenericCard, false },
 500     { "607", kGenericCard, false },
 501     { "608", kGenericCard, false },
 502     { "609", kGenericCard, false },
 503     { "61", kGenericCard, false },
 504     { "63", kGenericCard, false },
 505     { "640", kGenericCard, false },
 506     { "641", kGenericCard, false },
 507     { "642", kGenericCard, false },
 508     { "643", kGenericCard, false },
 509     { "66", kGenericCard, false },
 510     { "67", kGenericCard, false },
 511     { "68", kGenericCard, false },
 512     { "69", kGenericCard, false },
 513     { "7", kGenericCard, false },
 514     { "8", kGenericCard, false },
 515     { "9", kGenericCard, false },
 516
 517     // Oddball case: Unknown issuer, but valid Luhn check and plausible length.
 518     { "7000700070007000", kGenericCard, true },
 519   };
 520
 521   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
 522     base::string16 card_number = ASCIIToUTF16(test_cases[i].card_number);
 523     SCOPED_TRACE(card_number);
 524     EXPECT_EQ(test_cases[i].type, CreditCard::GetCreditCardType(card_number));
 525     EXPECT_EQ(test_cases[i].is_valid, IsValidCreditCardNumber(card_number));
 526   }
 527 }
 528
 529 }  // namespace autofill