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/webkit_resources.h" 14#include "testing/gtest/include/gtest/gtest.h" 15 16namespace autofill { 17namespace { 18 19// From https://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_numbers.htm 20const 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}; 42const 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. 54TEST(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 117TEST(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 131TEST(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 140TEST(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. 165TEST(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 180TEST(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 253TEST(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 274TEST(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 295TEST(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. 305TEST(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. 315TEST(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 342TEST(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 354TEST(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 363TEST(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 528