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 // This method is not compiled for iOS because these resources are not used and
 167 // should not be shipped.
 168 #if !defined(OS_IOS)
 169 // Test we get the correct icon for each card type.
 170 TEST(CreditCardTest, IconResourceId) {
 171   EXPECT_EQ(IDR_AUTOFILL_CC_AMEX,
 172             CreditCard::IconResourceId(kAmericanExpressCard));
 173   EXPECT_EQ(IDR_AUTOFILL_CC_DINERS,
 174             CreditCard::IconResourceId(kDinersCard));
 175   EXPECT_EQ(IDR_AUTOFILL_CC_DISCOVER,
 176             CreditCard::IconResourceId(kDiscoverCard));
 177   EXPECT_EQ(IDR_AUTOFILL_CC_JCB,
 178             CreditCard::IconResourceId(kJCBCard));
 179   EXPECT_EQ(IDR_AUTOFILL_CC_MASTERCARD,
 180             CreditCard::IconResourceId(kMasterCard));
 181   EXPECT_EQ(IDR_AUTOFILL_CC_VISA,
 182             CreditCard::IconResourceId(kVisaCard));
 183 }
 184 #endif  // #if !defined(OS_IOS)
 185
 186 TEST(CreditCardTest, UpdateFromImportedCard) {
 187   CreditCard original_card(base::GenerateGUID(), "https://www.example.com");
 188   test::SetCreditCardInfo(
 189       &original_card, "John Dillinger", "123456789012", "09", "2017");
 190
 191   CreditCard a = original_card;
 192
 193   // The new card has a different name, expiration date, and origin.
 194   CreditCard b = a;
 195   b.set_guid(base::GenerateGUID());
 196   b.set_origin("https://www.example.org");
 197   b.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("J. Dillinger"));
 198   b.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("08"));
 199   b.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2019"));
 200
 201   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 202   EXPECT_EQ("https://www.example.org", a.origin());
 203   EXPECT_EQ(ASCIIToUTF16("J. Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 204   EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 205   EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 206
 207   // Try again, but with no name set for |b|.
 208   a = original_card;
 209   b.SetRawInfo(CREDIT_CARD_NAME, base::string16());
 210
 211   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 212   EXPECT_EQ("https://www.example.org", a.origin());
 213   EXPECT_EQ(ASCIIToUTF16("John Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 214   EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 215   EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 216
 217   // Try again, but with only the original card having a verified origin.
 218   // |a| should be unchanged.
 219   a = original_card;
 220   a.set_origin("Chrome settings");
 221   b.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("J. Dillinger"));
 222
 223   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 224   EXPECT_EQ("Chrome settings", a.origin());
 225   EXPECT_EQ(ASCIIToUTF16("John Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 226   EXPECT_EQ(ASCIIToUTF16("09"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 227   EXPECT_EQ(ASCIIToUTF16("2017"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 228
 229   // Try again, but with only the new card having a verified origin.
 230   a = original_card;
 231   b.set_origin("Chrome settings");
 232
 233   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 234   EXPECT_EQ("Chrome settings", a.origin());
 235   EXPECT_EQ(ASCIIToUTF16("J. Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 236   EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 237   EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 238
 239   // Try again, with both cards having a verified origin.
 240   a = original_card;
 241   a.set_origin("Chrome Autofill dialog");
 242   b.set_origin("Chrome settings");
 243
 244   EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US"));
 245   EXPECT_EQ("Chrome settings", a.origin());
 246   EXPECT_EQ(ASCIIToUTF16("J. Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME));
 247   EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 248   EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 249
 250   // Try again, but with |b| having a different card number.
 251   // |a| should be unchanged.
 252   a = original_card;
 253   b.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111111111111111"));
 254
 255   EXPECT_FALSE(a.UpdateFromImportedCard(b, "en-US"));
 256   EXPECT_EQ(original_card, a);
 257 }
 258
 259 TEST(CreditCardTest, IsComplete) {
 260   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 261   EXPECT_FALSE(card.IsComplete());
 262   card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Wally T. Walrus"));
 263   EXPECT_FALSE(card.IsComplete());
 264   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01"));
 265   EXPECT_FALSE(card.IsComplete());
 266   card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2014"));
 267
 268   for (size_t i = 0; i < arraysize(kValidNumbers); ++i) {
 269     SCOPED_TRACE(kValidNumbers[i]);
 270     card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(kValidNumbers[i]));
 271     EXPECT_TRUE(card.IsComplete());
 272   }
 273   for (size_t i = 0; i < arraysize(kInvalidNumbers); ++i) {
 274     SCOPED_TRACE(kInvalidNumbers[i]);
 275     card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(kInvalidNumbers[i]));
 276     EXPECT_FALSE(card.IsComplete());
 277   }
 278 }
 279
 280 TEST(CreditCardTest, IsValid) {
 281   CreditCard card;
 282   // Invalid because expired
 283   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("1"));
 284   card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2010"));
 285   card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111111111111111"));
 286   EXPECT_FALSE(card.IsValid());
 287
 288   // Invalid because card number is not complete
 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("41111"));
 292   EXPECT_FALSE(card.IsValid());
 293
 294   // Valid
 295   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("12"));
 296   card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("9999"));
 297   card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111111111111111"));
 298   EXPECT_TRUE(card.IsValid());
 299 }
 300
 301 TEST(CreditCardTest, InvalidMastercardNumber) {
 302   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 303
 304   test::SetCreditCardInfo(&card, "Baby Face Nelson",
 305                           "5200000000000004", "01", "2010");
 306   EXPECT_EQ(kMasterCard, card.type());
 307   EXPECT_FALSE(card.IsComplete());
 308 }
 309
 310 // Verify that we preserve exactly what the user typed for credit card numbers.
 311 TEST(CreditCardTest, SetRawInfoCreditCardNumber) {
 312   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 313
 314   test::SetCreditCardInfo(&card, "Bob Dylan",
 315                           "4321-5432-6543-xxxx", "07", "2013");
 316   EXPECT_EQ(ASCIIToUTF16("4321-5432-6543-xxxx"),
 317             card.GetRawInfo(CREDIT_CARD_NUMBER));
 318 }
 319
 320 // Verify that we can handle both numeric and named months.
 321 TEST(CreditCardTest, SetExpirationMonth) {
 322   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 323
 324   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("05"));
 325   EXPECT_EQ(ASCIIToUTF16("05"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 326   EXPECT_EQ(5, card.expiration_month());
 327
 328   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("7"));
 329   EXPECT_EQ(ASCIIToUTF16("07"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 330   EXPECT_EQ(7, card.expiration_month());
 331
 332   // This should fail, and preserve the previous value.
 333   card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("January"));
 334   EXPECT_EQ(ASCIIToUTF16("07"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 335   EXPECT_EQ(7, card.expiration_month());
 336
 337   card.SetInfo(
 338       AutofillType(CREDIT_CARD_EXP_MONTH), ASCIIToUTF16("January"), "en-US");
 339   EXPECT_EQ(ASCIIToUTF16("01"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 340   EXPECT_EQ(1, card.expiration_month());
 341
 342   card.SetInfo(
 343       AutofillType(CREDIT_CARD_EXP_MONTH), ASCIIToUTF16("Apr"), "en-US");
 344   EXPECT_EQ(ASCIIToUTF16("04"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
 345   EXPECT_EQ(4, card.expiration_month());
 346 }
 347
 348 TEST(CreditCardTest, CreditCardType) {
 349   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 350
 351   // The card type cannot be set directly.
 352   card.SetRawInfo(CREDIT_CARD_TYPE, ASCIIToUTF16("Visa"));
 353   EXPECT_EQ(base::string16(), card.GetRawInfo(CREDIT_CARD_TYPE));
 354
 355   // Setting the number should implicitly set the type.
 356   card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111 1111 1111 1111"));
 357   EXPECT_EQ(ASCIIToUTF16("Visa"), card.GetRawInfo(CREDIT_CARD_TYPE));
 358 }
 359
 360 TEST(CreditCardTest, CreditCardVerificationCode) {
 361   CreditCard card(base::GenerateGUID(), "https://www.example.com/");
 362
 363   // The verification code cannot be set, as Chrome does not store this data.
 364   card.SetRawInfo(CREDIT_CARD_VERIFICATION_CODE, ASCIIToUTF16("999"));
 365   EXPECT_EQ(base::string16(), card.GetRawInfo(CREDIT_CARD_VERIFICATION_CODE));
 366 }
 367
 368
 369 TEST(CreditCardTest, GetCreditCardType) {
 370   struct {
 371     std::string card_number;
 372     std::string type;
 373     bool is_valid;
 374   } test_cases[] = {
 375     // The relevant sample numbers from
 376     // http://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_numbers.htm
 377     { "378282246310005", kAmericanExpressCard, true },
 378     { "371449635398431", kAmericanExpressCard, true },
 379     { "378734493671000", kAmericanExpressCard, true },
 380     { "30569309025904", kDinersCard, true },
 381     { "38520000023237", kDinersCard, true },
 382     { "6011111111111117", kDiscoverCard, true },
 383     { "6011000990139424", kDiscoverCard, true },
 384     { "3530111333300000", kJCBCard, true },
 385     { "3566002020360505", kJCBCard, true },
 386     { "5555555555554444", kMasterCard, true },
 387     { "5105105105105100", kMasterCard, true },
 388     { "4111111111111111", kVisaCard, true },
 389     { "4012888888881881", kVisaCard, true },
 390     { "4222222222222", kVisaCard, true },
 391
 392     // The relevant sample numbers from
 393     // http://auricsystems.com/support-center/sample-credit-card-numbers/
 394     { "343434343434343", kAmericanExpressCard, true },
 395     { "371144371144376", kAmericanExpressCard, true },
 396     { "341134113411347", kAmericanExpressCard, true },
 397     { "36438936438936", kDinersCard, true },
 398     { "36110361103612", kDinersCard, true },
 399     { "36111111111111", kDinersCard, true },
 400     { "6011016011016011", kDiscoverCard, true },
 401     { "6011000990139424", kDiscoverCard, true },
 402     { "6011000000000004", kDiscoverCard, true },
 403     { "6011000995500000", kDiscoverCard, true },
 404     { "6500000000000002", kDiscoverCard, true },
 405     { "3566002020360505", kJCBCard, true },
 406     { "3528000000000007", kJCBCard, true },
 407     { "5500005555555559", kMasterCard, true },
 408     { "5555555555555557", kMasterCard, true },
 409     { "5454545454545454", kMasterCard, true },
 410     { "5555515555555551", kMasterCard, true },
 411     { "5405222222222226", kMasterCard, true },
 412     { "5478050000000007", kMasterCard, true },
 413     { "5111005111051128", kMasterCard, true },
 414     { "5112345112345114", kMasterCard, true },
 415     { "5115915115915118", kMasterCard, true },
 416
 417     // A UnionPay card that doesn't pass the Luhn checksum
 418     { "6200000000000000", kUnionPay, true },
 419
 420     // Empty string
 421     { std::string(), kGenericCard, false },
 422
 423     // Non-numeric
 424     { "garbage", kGenericCard, false },
 425     { "4garbage", kVisaCard, false },
 426
 427     // Fails Luhn check.
 428     { "4111111111111112", kVisaCard, false },
 429
 430     // Invalid length.
 431     { "3434343434343434", kAmericanExpressCard, false },
 432     { "411111111111116", kVisaCard, false },
 433
 434     // Issuer Identification Numbers (IINs) that Chrome recognizes.
 435     { "4", kVisaCard, false },
 436     { "34", kAmericanExpressCard, false },
 437     { "37", kAmericanExpressCard, false },
 438     { "300", kDinersCard, false },
 439     { "301", kDinersCard, false },
 440     { "302", kDinersCard, false },
 441     { "303", kDinersCard, false },
 442     { "304", kDinersCard, false },
 443     { "305", kDinersCard, false },
 444     { "3095", kDinersCard, false },
 445     { "36", kDinersCard, false },
 446     { "38", kDinersCard, false },
 447     { "39", kDinersCard, false },
 448     { "6011", kDiscoverCard, false },
 449     { "644", kDiscoverCard, false },
 450     { "645", kDiscoverCard, false },
 451     { "646", kDiscoverCard, false },
 452     { "647", kDiscoverCard, false },
 453     { "648", kDiscoverCard, false },
 454     { "649", kDiscoverCard, false },
 455     { "65", kDiscoverCard, false },
 456     { "3528", kJCBCard, false },
 457     { "3531", kJCBCard, false },
 458     { "3589", kJCBCard, false },
 459     { "51", kMasterCard, false },
 460     { "52", kMasterCard, false },
 461     { "53", kMasterCard, false },
 462     { "54", kMasterCard, false },
 463     { "55", kMasterCard, false },
 464     { "62", kUnionPay, false },
 465
 466     // Not enough data to determine an IIN uniquely.
 467     { "3", kGenericCard, false },
 468     { "30", kGenericCard, false },
 469     { "309", kGenericCard, false },
 470     { "35", kGenericCard, false },
 471     { "5", kGenericCard, false },
 472     { "6", kGenericCard, false },
 473     { "60", kGenericCard, false },
 474     { "601", kGenericCard, false },
 475     { "64", kGenericCard, false },
 476
 477     // Unknown IINs.
 478     { "0", kGenericCard, false },
 479     { "1", kGenericCard, false },
 480     { "2", kGenericCard, false },
 481     { "306", kGenericCard, false },
 482     { "307", kGenericCard, false },
 483     { "308", kGenericCard, false },
 484     { "3091", kGenericCard, false },
 485     { "3094", kGenericCard, false },
 486     { "3096", kGenericCard, false },
 487     { "31", kGenericCard, false },
 488     { "32", kGenericCard, false },
 489     { "33", kGenericCard, false },
 490     { "351", kGenericCard, false },
 491     { "3527", kGenericCard, false },
 492     { "359", kGenericCard, false },
 493     { "50", kGenericCard, false },
 494     { "56", kGenericCard, false },
 495     { "57", kGenericCard, false },
 496     { "58", kGenericCard, false },
 497     { "59", kGenericCard, false },
 498     { "600", kGenericCard, false },
 499     { "602", kGenericCard, false },
 500     { "603", kGenericCard, false },
 501     { "604", kGenericCard, false },
 502     { "605", kGenericCard, false },
 503     { "606", kGenericCard, false },
 504     { "607", kGenericCard, false },
 505     { "608", kGenericCard, false },
 506     { "609", kGenericCard, false },
 507     { "61", kGenericCard, false },
 508     { "63", kGenericCard, false },
 509     { "640", kGenericCard, false },
 510     { "641", kGenericCard, false },
 511     { "642", kGenericCard, false },
 512     { "643", kGenericCard, false },
 513     { "66", kGenericCard, false },
 514     { "67", kGenericCard, false },
 515     { "68", kGenericCard, false },
 516     { "69", kGenericCard, false },
 517     { "7", kGenericCard, false },
 518     { "8", kGenericCard, false },
 519     { "9", kGenericCard, false },
 520
 521     // Oddball case: Unknown issuer, but valid Luhn check and plausible length.
 522     { "7000700070007000", kGenericCard, true },
 523   };
 524
 525   for (size_t i = 0; i < arraysize(test_cases); ++i) {
 526     base::string16 card_number = ASCIIToUTF16(test_cases[i].card_number);
 527     SCOPED_TRACE(card_number);
 528     EXPECT_EQ(test_cases[i].type, CreditCard::GetCreditCardType(card_number));
 529     EXPECT_EQ(test_cases[i].is_valid, IsValidCreditCardNumber(card_number));
 530   }
 531 }
 532
 533 }  // namespace autofill