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