Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(154)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: components/autofill/core/browser/credit_card_unittest.cc

Issue 2744933004: [Autofill] Rewrite Autofill unitttests to use INSTANTIATE_TEST_CASE_P (Closed)
Patch Set: remove commented test case. Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « components/autofill/core/browser/credit_card_field_unittest.cc ('k') | components/autofill/core/browser/personal_data_manager.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: components/autofill/core/browser/credit_card_unittest.cc
diff --git a/components/autofill/core/browser/credit_card_unittest.cc b/components/autofill/core/browser/credit_card_unittest.cc
index 993862f6d6dfef412c860a3acec4f91ef57d710b..4e371ec4656c77167a33d5b7c6407f6843fcae03 100644
--- a/components/autofill/core/browser/credit_card_unittest.cc
+++ b/components/autofill/core/browser/credit_card_unittest.cc
@@ -158,77 +158,90 @@ TEST(CreditCardTest, AssignmentOperator) {
EXPECT_TRUE(a == b);
}
-TEST(CreditCardTest, SetExpirationYearFromString) {
- static const struct {
- std::string expiration_year;
- int expected_year;
- } kTestCases[] = {
- // Valid values.
- {"2040", 2040},
- {"45", 2045},
- {"045", 2045},
- {"9", 2009},
-
- // Unrecognized year values.
- {"052045", 0},
- {"123", 0},
- {"y2045", 0},
- };
+struct SetExpirationYearFromStringTestCase {
+ std::string expiration_year;
+ int expected_year;
+};
- for (const auto& test_case : kTestCases) {
- CreditCard card(base::GenerateGUID(), "some origin");
- card.SetExpirationYearFromString(ASCIIToUTF16(test_case.expiration_year));
+class SetExpirationYearFromStringTest
+ : public testing::TestWithParam<SetExpirationYearFromStringTestCase> {};
- EXPECT_EQ(test_case.expected_year, card.expiration_year())
- << test_case.expiration_year << " " << test_case.expected_year;
- }
+TEST_P(SetExpirationYearFromStringTest, SetExpirationYearFromString) {
+ auto test_case = GetParam();
+ CreditCard card(base::GenerateGUID(), "some origin");
+ card.SetExpirationYearFromString(ASCIIToUTF16(test_case.expiration_year));
+
+ EXPECT_EQ(test_case.expected_year, card.expiration_year())
+ << test_case.expiration_year << " " << test_case.expected_year;
}
-TEST(CreditCardTest, SetExpirationDateFromString) {
- static const struct {
- std::string expiration_date;
- int expected_month;
- int expected_year;
- } kTestCases[] = {{"10", 0, 0}, // Too small.
- {"1020451", 0, 0}, // Too long.
-
- // No separators.
- {"105", 0, 0}, // Too ambiguous.
- {"0545", 5, 2045},
- {"52045", 0, 0}, // Too ambiguous.
- {"052045", 5, 2045},
-
- // "/" separator.
- {"05/45", 5, 2045},
- {"5/2045", 5, 2045},
- {"05/2045", 5, 2045},
-
- // "-" separator.
- {"05-45", 5, 2045},
- {"5-2045", 5, 2045},
- {"05-2045", 5, 2045},
-
- // "|" separator.
- {"05|45", 5, 2045},
- {"5|2045", 5, 2045},
- {"05|2045", 5, 2045},
-
- // Invalid values.
- {"13/2016", 0, 2016},
- {"16/13", 0, 2013},
- {"May-2015", 0, 0},
- {"05-/2045", 0, 0},
- {"05_2045", 0, 0}};
+INSTANTIATE_TEST_CASE_P(CreditCardTest,
+ SetExpirationYearFromStringTest,
+ testing::Values(
+ // Valid values.
+ SetExpirationYearFromStringTestCase{"2040", 2040},
+ SetExpirationYearFromStringTestCase{"45", 2045},
+ SetExpirationYearFromStringTestCase{"045", 2045},
+ SetExpirationYearFromStringTestCase{"9", 2009},
+
+ // Unrecognized year values.
+ SetExpirationYearFromStringTestCase{"052045", 0},
+ SetExpirationYearFromStringTestCase{"123", 0},
+ SetExpirationYearFromStringTestCase{"y2045", 0}));
+
+struct SetExpirationDateFromStringTestCase {
+ std::string expiration_date;
+ int expected_month;
+ int expected_year;
+};
- for (const auto& test_case : kTestCases) {
- CreditCard card(base::GenerateGUID(), "some origin");
- card.SetExpirationDateFromString(ASCIIToUTF16(test_case.expiration_date));
+class SetExpirationDateFromStringTest
+ : public testing::TestWithParam<SetExpirationDateFromStringTestCase> {};
- EXPECT_EQ(test_case.expected_month, card.expiration_month());
- EXPECT_EQ(test_case.expected_year, card.expiration_year());
- }
+TEST_P(SetExpirationDateFromStringTest, SetExpirationDateFromString) {
+ auto test_case = GetParam();
+ CreditCard card(base::GenerateGUID(), "some origin");
+ card.SetExpirationDateFromString(ASCIIToUTF16(test_case.expiration_date));
+
+ EXPECT_EQ(test_case.expected_month, card.expiration_month());
+ EXPECT_EQ(test_case.expected_year, card.expiration_year());
}
+INSTANTIATE_TEST_CASE_P(
+ CreditCardTest,
+ SetExpirationDateFromStringTest,
+ testing::Values(
+ SetExpirationDateFromStringTestCase{"10", 0, 0}, // Too small.
+ SetExpirationDateFromStringTestCase{"1020451", 0, 0}, // Too long.
+
+ // No separators.
+ SetExpirationDateFromStringTestCase{"105", 0, 0}, // Too ambiguous.
+ SetExpirationDateFromStringTestCase{"0545", 5, 2045},
+ SetExpirationDateFromStringTestCase{"52045", 0, 0}, // Too ambiguous.
+ SetExpirationDateFromStringTestCase{"052045", 5, 2045},
+
+ // "/" separator.
+ SetExpirationDateFromStringTestCase{"05/45", 5, 2045},
+ SetExpirationDateFromStringTestCase{"5/2045", 5, 2045},
+ SetExpirationDateFromStringTestCase{"05/2045", 5, 2045},
+
+ // "-" separator.
+ SetExpirationDateFromStringTestCase{"05-45", 5, 2045},
+ SetExpirationDateFromStringTestCase{"5-2045", 5, 2045},
+ SetExpirationDateFromStringTestCase{"05-2045", 5, 2045},
+
+ // "|" separator.
+ SetExpirationDateFromStringTestCase{"05|45", 5, 2045},
+ SetExpirationDateFromStringTestCase{"5|2045", 5, 2045},
+ SetExpirationDateFromStringTestCase{"05|2045", 5, 2045},
+
+ // Invalid values.
+ SetExpirationDateFromStringTestCase{"13/2016", 0, 2016},
+ SetExpirationDateFromStringTestCase{"16/13", 0, 2013},
+ SetExpirationDateFromStringTestCase{"May-2015", 0, 0},
+ SetExpirationDateFromStringTestCase{"05-/2045", 0, 0},
+ SetExpirationDateFromStringTestCase{"05_2045", 0, 0}));
+
TEST(CreditCardTest, Copy) {
CreditCard a(base::GenerateGUID(), "https://www.example.com");
test::SetCreditCardInfo(&a, "John Dillinger", "123456789012", "01", "2010");
@@ -238,73 +251,85 @@ TEST(CreditCardTest, Copy) {
EXPECT_TRUE(a == b);
}
-TEST(CreditCardTest, IsLocalDuplicateOfServerCard) {
- struct {
- CreditCard::RecordType first_card_record_type;
- const char* first_card_name;
- const char* first_card_number;
- const char* first_card_exp_mo;
- const char* first_card_exp_yr;
-
- CreditCard::RecordType second_card_record_type;
- const char* second_card_name;
- const char* second_card_number;
- const char* second_card_exp_mo;
- const char* second_card_exp_yr;
- const char* second_card_type;
-
- bool is_local_duplicate;
- } test_cases[] = {
- { LOCAL_CARD, "", "", "", "",
- LOCAL_CARD, "", "", "", "", nullptr, false },
- { LOCAL_CARD, "", "", "", "",
- FULL_SERVER_CARD, "", "", "", "", nullptr, true},
- { FULL_SERVER_CARD, "", "", "", "",
- FULL_SERVER_CARD, "", "", "", "", nullptr, false},
- { LOCAL_CARD, "John Dillinger", "423456789012", "01", "2010",
- FULL_SERVER_CARD, "John Dillinger", "423456789012", "01", "2010", nullptr,
- true },
- { LOCAL_CARD, "J Dillinger", "423456789012", "01", "2010",
- FULL_SERVER_CARD, "John Dillinger", "423456789012", "01", "2010", nullptr,
- false },
- { LOCAL_CARD, "", "423456789012", "01", "2010",
- FULL_SERVER_CARD, "John Dillinger", "423456789012", "01", "2010", nullptr,
- true },
- { LOCAL_CARD, "", "423456789012", "", "",
- FULL_SERVER_CARD, "John Dillinger", "423456789012", "01", "2010", nullptr,
- true },
- { LOCAL_CARD, "", "423456789012", "", "",
- MASKED_SERVER_CARD, "John Dillinger", "9012", "01", "2010", kVisaCard,
- true },
- { LOCAL_CARD, "", "423456789012", "", "",
- MASKED_SERVER_CARD, "John Dillinger", "9012", "01", "2010", kMasterCard,
- false },
- { LOCAL_CARD, "John Dillinger", "4234-5678-9012", "01", "2010",
- FULL_SERVER_CARD, "John Dillinger", "423456789012", "01", "2010", nullptr,
- true },
- };
+struct IsLocalDuplicateOfServerCardTestCase {
+ CreditCard::RecordType first_card_record_type;
+ const char* first_card_name;
+ const char* first_card_number;
+ const char* first_card_exp_mo;
+ const char* first_card_exp_yr;
+
+ CreditCard::RecordType second_card_record_type;
+ const char* second_card_name;
+ const char* second_card_number;
+ const char* second_card_exp_mo;
+ const char* second_card_exp_yr;
+ const char* second_card_type;
+
+ bool is_local_duplicate;
+};
- for (const auto& test_case : test_cases) {
- CreditCard a(base::GenerateGUID(), std::string());
- a.set_record_type(test_case.first_card_record_type);
- test::SetCreditCardInfo(
- &a, test_case.first_card_name, test_case.first_card_number,
- test_case.first_card_exp_mo, test_case.first_card_exp_yr);
+class IsLocalDuplicateOfServerCardTest
+ : public testing::TestWithParam<IsLocalDuplicateOfServerCardTestCase> {};
- CreditCard b(base::GenerateGUID(), std::string());
- b.set_record_type(test_case.second_card_record_type);
- test::SetCreditCardInfo(
- &b, test_case.second_card_name, test_case.second_card_number,
- test_case.second_card_exp_mo, test_case.second_card_exp_yr);
+TEST_P(IsLocalDuplicateOfServerCardTest, IsLocalDuplicateOfServerCard) {
+ auto test_case = GetParam();
+ CreditCard a(base::GenerateGUID(), std::string());
+ a.set_record_type(test_case.first_card_record_type);
+ test::SetCreditCardInfo(
+ &a, test_case.first_card_name, test_case.first_card_number,
+ test_case.first_card_exp_mo, test_case.first_card_exp_yr);
- if (test_case.second_card_record_type == CreditCard::MASKED_SERVER_CARD)
- b.SetTypeForMaskedCard(test_case.second_card_type);
+ CreditCard b(base::GenerateGUID(), std::string());
+ b.set_record_type(test_case.second_card_record_type);
+ test::SetCreditCardInfo(
+ &b, test_case.second_card_name, test_case.second_card_number,
+ test_case.second_card_exp_mo, test_case.second_card_exp_yr);
- EXPECT_EQ(test_case.is_local_duplicate, a.IsLocalDuplicateOfServerCard(b))
- << " when comparing cards " << a.Label() << " and " << b.Label();
- }
+ if (test_case.second_card_record_type == CreditCard::MASKED_SERVER_CARD)
+ b.SetTypeForMaskedCard(test_case.second_card_type);
+
+ EXPECT_EQ(test_case.is_local_duplicate, a.IsLocalDuplicateOfServerCard(b))
+ << " when comparing cards " << a.Label() << " and " << b.Label();
}
+INSTANTIATE_TEST_CASE_P(
+ CreditCardTest,
+ IsLocalDuplicateOfServerCardTest,
+ testing::Values(
+ IsLocalDuplicateOfServerCardTestCase{LOCAL_CARD, "", "", "", "",
+ LOCAL_CARD, "", "", "", "",
+ nullptr, false},
+ IsLocalDuplicateOfServerCardTestCase{LOCAL_CARD, "", "", "", "",
+ FULL_SERVER_CARD, "", "", "", "",
+ nullptr, true},
+ IsLocalDuplicateOfServerCardTestCase{FULL_SERVER_CARD, "", "", "", "",
+ FULL_SERVER_CARD, "", "", "", "",
+ nullptr, false},
+ IsLocalDuplicateOfServerCardTestCase{
+ LOCAL_CARD, "John Dillinger", "423456789012", "01", "2010",
+ FULL_SERVER_CARD, "John Dillinger", "423456789012", "01", "2010",
+ nullptr, true},
+ IsLocalDuplicateOfServerCardTestCase{
+ LOCAL_CARD, "J Dillinger", "423456789012", "01", "2010",
+ FULL_SERVER_CARD, "John Dillinger", "423456789012", "01", "2010",
+ nullptr, false},
+ IsLocalDuplicateOfServerCardTestCase{
+ LOCAL_CARD, "", "423456789012", "01", "2010", FULL_SERVER_CARD,
+ "John Dillinger", "423456789012", "01", "2010", nullptr, true},
+ IsLocalDuplicateOfServerCardTestCase{
+ LOCAL_CARD, "", "423456789012", "", "", FULL_SERVER_CARD,
+ "John Dillinger", "423456789012", "01", "2010", nullptr, true},
+ IsLocalDuplicateOfServerCardTestCase{
+ LOCAL_CARD, "", "423456789012", "", "", MASKED_SERVER_CARD,
+ "John Dillinger", "9012", "01", "2010", kVisaCard, true},
+ IsLocalDuplicateOfServerCardTestCase{
+ LOCAL_CARD, "", "423456789012", "", "", MASKED_SERVER_CARD,
+ "John Dillinger", "9012", "01", "2010", kMasterCard, false},
+ IsLocalDuplicateOfServerCardTestCase{
+ LOCAL_CARD, "John Dillinger", "4234-5678-9012", "01", "2010",
+ FULL_SERVER_CARD, "John Dillinger", "423456789012", "01", "2010",
+ nullptr, true}));
+
TEST(CreditCardTest, HasSameNumberAs) {
CreditCard a(base::GenerateGUID(), std::string());
CreditCard b(base::GenerateGUID(), std::string());
@@ -603,178 +628,223 @@ TEST(CreditCardTest, CreditCardVerificationCode) {
EXPECT_EQ(base::string16(), card.GetRawInfo(CREDIT_CARD_VERIFICATION_CODE));
}
+struct GetCreditCardTypeTestCase {
+ std::string card_number;
+ std::string type;
+ bool is_valid;
+};
-TEST(CreditCardTest, GetCreditCardType) {
- struct {
- std::string card_number;
- std::string type;
- bool is_valid;
- } test_cases[] = {
- // The relevant sample numbers from
- // http://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_numbers.htm
- { "378282246310005", kAmericanExpressCard, true },
- { "371449635398431", kAmericanExpressCard, true },
- { "378734493671000", kAmericanExpressCard, true },
- { "30569309025904", kDinersCard, true },
- { "38520000023237", kDinersCard, true },
- { "6011111111111117", kDiscoverCard, true },
- { "6011000990139424", kDiscoverCard, true },
- { "3530111333300000", kJCBCard, true },
- { "3566002020360505", kJCBCard, true },
- { "5555555555554444", kMasterCard, true },
- { "5105105105105100", kMasterCard, true },
- { "4111111111111111", kVisaCard, true },
- { "4012888888881881", kVisaCard, true },
- { "4222222222222", kVisaCard, true },
-
- // The relevant sample numbers from
- // https://www.auricsystems.com/sample-credit-card-numbers/
- { "343434343434343", kAmericanExpressCard, true },
- { "371144371144376", kAmericanExpressCard, true },
- { "341134113411347", kAmericanExpressCard, true },
- { "36438936438936", kDinersCard, true },
- { "36110361103612", kDinersCard, true },
- { "36111111111111", kDinersCard, true },
- { "6011016011016011", kDiscoverCard, true },
- { "6011000990139424", kDiscoverCard, true },
- { "6011000000000004", kDiscoverCard, true },
- { "6011000995500000", kDiscoverCard, true },
- { "6500000000000002", kDiscoverCard, true },
- { "3566002020360505", kJCBCard, true },
- { "3528000000000007", kJCBCard, true },
- { "5500005555555559", kMasterCard, true },
- { "5555555555555557", kMasterCard, true },
- { "5454545454545454", kMasterCard, true },
- { "5555515555555551", kMasterCard, true },
- { "5405222222222226", kMasterCard, true },
- { "5478050000000007", kMasterCard, true },
- { "5111005111051128", kMasterCard, true },
- { "5112345112345114", kMasterCard, true },
- { "5115915115915118", kMasterCard, true },
- { "6247130048162403", kUnionPay, true },
- { "6247130048162403", kUnionPay, true },
- { "622384452162063648", kUnionPay, true },
- { "2204883716636153", kMirCard, true },
- { "2200111234567898", kMirCard, true },
- { "2200481349288130", kMirCard, true },
-
- // Empty string
- { std::string(), kGenericCard, false },
-
- // Non-numeric
- { "garbage", kGenericCard, false },
- { "4garbage", kVisaCard, false },
-
- // Fails Luhn check.
- { "4111111111111112", kVisaCard, false },
- { "6247130048162413", kUnionPay, false },
- { "2204883716636154", kMirCard, false },
-
- // Invalid length.
- { "3434343434343434", kAmericanExpressCard, false },
- { "411111111111116", kVisaCard, false },
- { "220011123456783", kMirCard, false },
-
- // Issuer Identification Numbers (IINs) that Chrome recognizes.
- { "4", kVisaCard, false },
- { "22", kMirCard, false },
- { "34", kAmericanExpressCard, false },
- { "37", kAmericanExpressCard, false },
- { "300", kDinersCard, false },
- { "301", kDinersCard, false },
- { "302", kDinersCard, false },
- { "303", kDinersCard, false },
- { "304", kDinersCard, false },
- { "305", kDinersCard, false },
- { "3095", kDinersCard, false },
- { "36", kDinersCard, false },
- { "38", kDinersCard, false },
- { "39", kDinersCard, false },
- { "6011", kDiscoverCard, false },
- { "644", kDiscoverCard, false },
- { "645", kDiscoverCard, false },
- { "646", kDiscoverCard, false },
- { "647", kDiscoverCard, false },
- { "648", kDiscoverCard, false },
- { "649", kDiscoverCard, false },
- { "65", kDiscoverCard, false },
- { "3528", kJCBCard, false },
- { "3531", kJCBCard, false },
- { "3589", kJCBCard, false },
- { "51", kMasterCard, false },
- { "52", kMasterCard, false },
- { "53", kMasterCard, false },
- { "54", kMasterCard, false },
- { "55", kMasterCard, false },
- { "62", kUnionPay, false },
-
- // Not enough data to determine an IIN uniquely.
- { "2", kGenericCard, false },
- { "3", kGenericCard, false },
- { "30", kGenericCard, false },
- { "309", kGenericCard, false },
- { "35", kGenericCard, false },
- { "5", kGenericCard, false },
- { "6", kGenericCard, false },
- { "60", kGenericCard, false },
- { "601", kGenericCard, false },
- { "64", kGenericCard, false },
-
- // Unknown IINs.
- { "0", kGenericCard, false },
- { "1", kGenericCard, false },
- { "306", kGenericCard, false },
- { "307", kGenericCard, false },
- { "308", kGenericCard, false },
- { "3091", kGenericCard, false },
- { "3094", kGenericCard, false },
- { "3096", kGenericCard, false },
- { "31", kGenericCard, false },
- { "32", kGenericCard, false },
- { "33", kGenericCard, false },
- { "351", kGenericCard, false },
- { "3527", kGenericCard, false },
- { "359", kGenericCard, false },
- { "50", kGenericCard, false },
- { "56", kGenericCard, false },
- { "57", kGenericCard, false },
- { "58", kGenericCard, false },
- { "59", kGenericCard, false },
- { "600", kGenericCard, false },
- { "602", kGenericCard, false },
- { "603", kGenericCard, false },
- { "604", kGenericCard, false },
- { "605", kGenericCard, false },
- { "606", kGenericCard, false },
- { "607", kGenericCard, false },
- { "608", kGenericCard, false },
- { "609", kGenericCard, false },
- { "61", kGenericCard, false },
- { "63", kGenericCard, false },
- { "640", kGenericCard, false },
- { "641", kGenericCard, false },
- { "642", kGenericCard, false },
- { "643", kGenericCard, false },
- { "66", kGenericCard, false },
- { "67", kGenericCard, false },
- { "68", kGenericCard, false },
- { "69", kGenericCard, false },
- { "7", kGenericCard, false },
- { "8", kGenericCard, false },
- { "9", kGenericCard, false },
-
- // Oddball case: Unknown issuer, but valid Luhn check and plausible length.
- { "7000700070007000", kGenericCard, true },
- };
+// We are doing batches here because INSTANTIATE_TEST_CASE_P has a
+// 50 upper limit.
+class GetCreditCardTypeTestBatch1
+ : public testing::TestWithParam<GetCreditCardTypeTestCase> {};
+
+TEST_P(GetCreditCardTypeTestBatch1, GetCreditCardType) {
+ auto test_case = GetParam();
+ base::string16 card_number = ASCIIToUTF16(test_case.card_number);
+ SCOPED_TRACE(card_number);
+ EXPECT_EQ(test_case.type, CreditCard::GetCreditCardType(card_number));
+ EXPECT_EQ(test_case.is_valid, IsValidCreditCardNumber(card_number));
+}
- for (const auto& test_case : test_cases) {
- base::string16 card_number = ASCIIToUTF16(test_case.card_number);
- SCOPED_TRACE(card_number);
- EXPECT_EQ(test_case.type, CreditCard::GetCreditCardType(card_number));
- EXPECT_EQ(test_case.is_valid, IsValidCreditCardNumber(card_number));
- }
+INSTANTIATE_TEST_CASE_P(
+ CreditCardTest,
+ GetCreditCardTypeTestBatch1,
+ testing::Values(
+ // The relevant sample numbers from
+ // http://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_numbers.htm
+ GetCreditCardTypeTestCase{"378282246310005", kAmericanExpressCard,
+ true},
+ GetCreditCardTypeTestCase{"371449635398431", kAmericanExpressCard,
+ true},
+ GetCreditCardTypeTestCase{"378734493671000", kAmericanExpressCard,
+ true},
+ GetCreditCardTypeTestCase{"30569309025904", kDinersCard, true},
+ GetCreditCardTypeTestCase{"38520000023237", kDinersCard, true},
+ GetCreditCardTypeTestCase{"6011111111111117", kDiscoverCard, true},
+ GetCreditCardTypeTestCase{"6011000990139424", kDiscoverCard, true},
+ GetCreditCardTypeTestCase{"3530111333300000", kJCBCard, true},
+ GetCreditCardTypeTestCase{"3566002020360505", kJCBCard, true},
+ GetCreditCardTypeTestCase{"5555555555554444", kMasterCard, true},
+ GetCreditCardTypeTestCase{"5105105105105100", kMasterCard, true},
+ GetCreditCardTypeTestCase{"4111111111111111", kVisaCard, true},
+ GetCreditCardTypeTestCase{"4012888888881881", kVisaCard, true},
+ GetCreditCardTypeTestCase{"4222222222222", kVisaCard, true},
+
+ // The relevant sample numbers from
+ // https://www.auricsystems.com/sample-credit-card-numbers/
+ GetCreditCardTypeTestCase{"343434343434343", kAmericanExpressCard,
+ true},
+ GetCreditCardTypeTestCase{"371144371144376", kAmericanExpressCard,
+ true},
+ GetCreditCardTypeTestCase{"341134113411347", kAmericanExpressCard,
+ true},
+ GetCreditCardTypeTestCase{"36438936438936", kDinersCard, true},
+ GetCreditCardTypeTestCase{"36110361103612", kDinersCard, true},
+ GetCreditCardTypeTestCase{"36111111111111", kDinersCard, true},
+ GetCreditCardTypeTestCase{"6011016011016011", kDiscoverCard, true},
+ GetCreditCardTypeTestCase{"6011000990139424", kDiscoverCard, true},
+ GetCreditCardTypeTestCase{"6011000000000004", kDiscoverCard, true},
+ GetCreditCardTypeTestCase{"6011000995500000", kDiscoverCard, true},
+ GetCreditCardTypeTestCase{"6500000000000002", kDiscoverCard, true},
+ GetCreditCardTypeTestCase{"3566002020360505", kJCBCard, true},
+ GetCreditCardTypeTestCase{"3528000000000007", kJCBCard, true},
+ GetCreditCardTypeTestCase{"5500005555555559", kMasterCard, true},
+ GetCreditCardTypeTestCase{"5555555555555557", kMasterCard, true},
+ GetCreditCardTypeTestCase{"5454545454545454", kMasterCard, true},
+ GetCreditCardTypeTestCase{"5555515555555551", kMasterCard, true},
+ GetCreditCardTypeTestCase{"5405222222222226", kMasterCard, true},
+ GetCreditCardTypeTestCase{"5478050000000007", kMasterCard, true},
+ GetCreditCardTypeTestCase{"5111005111051128", kMasterCard, true},
+ GetCreditCardTypeTestCase{"5112345112345114", kMasterCard, true},
+ GetCreditCardTypeTestCase{"5115915115915118", kMasterCard, true},
+ GetCreditCardTypeTestCase{"6247130048162403", kUnionPay, true},
+ GetCreditCardTypeTestCase{"6247130048162403", kUnionPay, true},
+ GetCreditCardTypeTestCase{"622384452162063648", kUnionPay, true},
+ GetCreditCardTypeTestCase{"2204883716636153", kMirCard, true},
+ GetCreditCardTypeTestCase{"2200111234567898", kMirCard, true},
+ GetCreditCardTypeTestCase{"2200481349288130", kMirCard, true},
+
+ // Empty string
+ GetCreditCardTypeTestCase{std::string(), kGenericCard, false},
+
+ // Non-numeric
+ GetCreditCardTypeTestCase{"garbage", kGenericCard, false},
+ GetCreditCardTypeTestCase{"4garbage", kVisaCard, false},
+
+ // Fails Luhn check.
+ GetCreditCardTypeTestCase{"4111111111111112", kVisaCard, false},
+ GetCreditCardTypeTestCase{"6247130048162413", kUnionPay, false},
+ GetCreditCardTypeTestCase{"2204883716636154", kMirCard, false}));
+
+class GetCreditCardTypeTestBatch2
+ : public testing::TestWithParam<GetCreditCardTypeTestCase> {};
+
+TEST_P(GetCreditCardTypeTestBatch2, GetCreditCardType) {
+ auto test_case = GetParam();
+ base::string16 card_number = ASCIIToUTF16(test_case.card_number);
+ SCOPED_TRACE(card_number);
+ EXPECT_EQ(test_case.type, CreditCard::GetCreditCardType(card_number));
+ EXPECT_EQ(test_case.is_valid, IsValidCreditCardNumber(card_number));
+}
+
+INSTANTIATE_TEST_CASE_P(
+ CreditCardTest,
+ GetCreditCardTypeTestBatch2,
+ testing::Values(
+ // Invalid length.
+ GetCreditCardTypeTestCase{"3434343434343434", kAmericanExpressCard,
+ false},
+ GetCreditCardTypeTestCase{"411111111111116", kVisaCard, false},
+ GetCreditCardTypeTestCase{"220011123456783", kMirCard, false},
+
+ // Issuer Identification Numbers (IINs) that Chrome recognizes.
+ GetCreditCardTypeTestCase{"4", kVisaCard, false},
+ GetCreditCardTypeTestCase{"22", kMirCard, false},
+ GetCreditCardTypeTestCase{"34", kAmericanExpressCard, false},
+ GetCreditCardTypeTestCase{"37", kAmericanExpressCard, false},
+ GetCreditCardTypeTestCase{"300", kDinersCard, false},
+ GetCreditCardTypeTestCase{"301", kDinersCard, false},
+ GetCreditCardTypeTestCase{"302", kDinersCard, false},
+ GetCreditCardTypeTestCase{"303", kDinersCard, false},
+ GetCreditCardTypeTestCase{"304", kDinersCard, false},
+ GetCreditCardTypeTestCase{"305", kDinersCard, false},
+ GetCreditCardTypeTestCase{"3095", kDinersCard, false},
+ GetCreditCardTypeTestCase{"36", kDinersCard, false},
+ GetCreditCardTypeTestCase{"38", kDinersCard, false},
+ GetCreditCardTypeTestCase{"39", kDinersCard, false},
+ GetCreditCardTypeTestCase{"6011", kDiscoverCard, false},
+ GetCreditCardTypeTestCase{"644", kDiscoverCard, false},
+ GetCreditCardTypeTestCase{"645", kDiscoverCard, false},
+ GetCreditCardTypeTestCase{"646", kDiscoverCard, false},
+ GetCreditCardTypeTestCase{"647", kDiscoverCard, false},
+ GetCreditCardTypeTestCase{"648", kDiscoverCard, false},
+ GetCreditCardTypeTestCase{"649", kDiscoverCard, false},
+ GetCreditCardTypeTestCase{"65", kDiscoverCard, false},
+ GetCreditCardTypeTestCase{"3528", kJCBCard, false},
+ GetCreditCardTypeTestCase{"3531", kJCBCard, false},
+ GetCreditCardTypeTestCase{"3589", kJCBCard, false},
+ GetCreditCardTypeTestCase{"51", kMasterCard, false},
+ GetCreditCardTypeTestCase{"52", kMasterCard, false},
+ GetCreditCardTypeTestCase{"53", kMasterCard, false},
+ GetCreditCardTypeTestCase{"54", kMasterCard, false},
+ GetCreditCardTypeTestCase{"55", kMasterCard, false},
+ GetCreditCardTypeTestCase{"62", kUnionPay, false},
+
+ // Not enough data to determine an IIN uniquely.
+ GetCreditCardTypeTestCase{"2", kGenericCard, false},
+ GetCreditCardTypeTestCase{"3", kGenericCard, false},
+ GetCreditCardTypeTestCase{"30", kGenericCard, false},
+ GetCreditCardTypeTestCase{"309", kGenericCard, false},
+ GetCreditCardTypeTestCase{"35", kGenericCard, false},
+ GetCreditCardTypeTestCase{"5", kGenericCard, false},
+ GetCreditCardTypeTestCase{"6", kGenericCard, false},
+ GetCreditCardTypeTestCase{"60", kGenericCard, false},
+ GetCreditCardTypeTestCase{"601", kGenericCard, false},
+ GetCreditCardTypeTestCase{"64", kGenericCard, false}));
+
+class GetCreditCardTypeTestBatch3
+ : public testing::TestWithParam<GetCreditCardTypeTestCase> {};
+
+TEST_P(GetCreditCardTypeTestBatch3, GetCreditCardType) {
+ auto test_case = GetParam();
+ base::string16 card_number = ASCIIToUTF16(test_case.card_number);
+ SCOPED_TRACE(card_number);
+ EXPECT_EQ(test_case.type, CreditCard::GetCreditCardType(card_number));
+ EXPECT_EQ(test_case.is_valid, IsValidCreditCardNumber(card_number));
}
+INSTANTIATE_TEST_CASE_P(
+ CreditCardTest,
+ GetCreditCardTypeTestBatch3,
+ testing::Values(
+ // Unknown IINs.
+ GetCreditCardTypeTestCase{"0", kGenericCard, false},
+ GetCreditCardTypeTestCase{"1", kGenericCard, false},
+ GetCreditCardTypeTestCase{"306", kGenericCard, false},
+ GetCreditCardTypeTestCase{"307", kGenericCard, false},
+ GetCreditCardTypeTestCase{"308", kGenericCard, false},
+ GetCreditCardTypeTestCase{"3091", kGenericCard, false},
+ GetCreditCardTypeTestCase{"3094", kGenericCard, false},
+ GetCreditCardTypeTestCase{"3096", kGenericCard, false},
+ GetCreditCardTypeTestCase{"31", kGenericCard, false},
+ GetCreditCardTypeTestCase{"32", kGenericCard, false},
+ GetCreditCardTypeTestCase{"33", kGenericCard, false},
+ GetCreditCardTypeTestCase{"351", kGenericCard, false},
+ GetCreditCardTypeTestCase{"3527", kGenericCard, false},
+ GetCreditCardTypeTestCase{"359", kGenericCard, false},
+ GetCreditCardTypeTestCase{"50", kGenericCard, false},
+ GetCreditCardTypeTestCase{"56", kGenericCard, false},
+ GetCreditCardTypeTestCase{"57", kGenericCard, false},
+ GetCreditCardTypeTestCase{"58", kGenericCard, false},
+ GetCreditCardTypeTestCase{"59", kGenericCard, false},
+ GetCreditCardTypeTestCase{"600", kGenericCard, false},
+ GetCreditCardTypeTestCase{"602", kGenericCard, false},
+ GetCreditCardTypeTestCase{"603", kGenericCard, false},
+ GetCreditCardTypeTestCase{"604", kGenericCard, false},
+ GetCreditCardTypeTestCase{"605", kGenericCard, false},
+ GetCreditCardTypeTestCase{"606", kGenericCard, false},
+ GetCreditCardTypeTestCase{"607", kGenericCard, false},
+ GetCreditCardTypeTestCase{"608", kGenericCard, false},
+ GetCreditCardTypeTestCase{"609", kGenericCard, false},
+ GetCreditCardTypeTestCase{"61", kGenericCard, false},
+ GetCreditCardTypeTestCase{"63", kGenericCard, false},
+ GetCreditCardTypeTestCase{"640", kGenericCard, false},
+ GetCreditCardTypeTestCase{"641", kGenericCard, false},
+ GetCreditCardTypeTestCase{"642", kGenericCard, false},
+ GetCreditCardTypeTestCase{"643", kGenericCard, false},
+ GetCreditCardTypeTestCase{"66", kGenericCard, false},
+ GetCreditCardTypeTestCase{"67", kGenericCard, false},
+ GetCreditCardTypeTestCase{"68", kGenericCard, false},
+ GetCreditCardTypeTestCase{"69", kGenericCard, false},
+ GetCreditCardTypeTestCase{"7", kGenericCard, false},
+ GetCreditCardTypeTestCase{"8", kGenericCard, false},
+ GetCreditCardTypeTestCase{"9", kGenericCard, false},
+
+ // Oddball case: Unknown issuer, but valid Luhn check and plausible
+ // length.
+ GetCreditCardTypeTestCase{"7000700070007000", kGenericCard, true}));
+
TEST(CreditCardTest, LastFourDigits) {
CreditCard card(base::GenerateGUID(), "https://www.example.com/");
ASSERT_EQ(base::string16(), card.LastFourDigits());
@@ -791,104 +861,149 @@ TEST(CreditCardTest, LastFourDigits) {
}
// Verifies that a credit card should be updated.
-TEST(CreditCardTest, ShouldUpdateExpiration) {
- base::Time now = base::Time::Now();
-
- base::Time::Exploded last_year;
- (now - base::TimeDelta::FromDays(365)).LocalExplode(&last_year);
-
- base::Time::Exploded last_month;
- (now - base::TimeDelta::FromDays(31)).LocalExplode(&last_month);
-
- base::Time::Exploded current;
- now.LocalExplode(&current);
-
- base::Time::Exploded next_month;
- (now + base::TimeDelta::FromDays(31)).LocalExplode(&next_month);
+struct ShouldUpdateExpirationTestCase {
+ bool should_update_expiration;
+ int month;
+ int year;
+ CreditCard::RecordType record_type;
+ CreditCard::ServerStatus server_status;
+};
- base::Time::Exploded next_year;
- (now + base::TimeDelta::FromDays(365)).LocalExplode(&next_year);
+class ShouldUpdateExpirationTest
+ : public testing::TestWithParam<ShouldUpdateExpirationTestCase> {};
+
+class TestingTimes {
+ public:
+ TestingTimes() {
+ now_ = base::Time::Now();
+ (now_ - base::TimeDelta::FromDays(365)).LocalExplode(&last_year_);
+ (now_ - base::TimeDelta::FromDays(31)).LocalExplode(&last_month_);
+ now_.LocalExplode(&current_);
+ (now_ + base::TimeDelta::FromDays(31)).LocalExplode(&next_month_);
+ (now_ + base::TimeDelta::FromDays(365)).LocalExplode(&next_year_);
+ }
- static const struct {
- bool should_update_expiration;
- int month;
- int year;
- CreditCard::RecordType record_type;
- CreditCard::ServerStatus server_status;
- } kTestCases[] = {
+ base::Time now_;
+ base::Time::Exploded last_year_;
+ base::Time::Exploded last_month_;
+ base::Time::Exploded current_;
+ base::Time::Exploded next_month_;
+ base::Time::Exploded next_year_;
+};
- // Cards that expired last year should always be updated.
- {true, last_year.month, last_year.year, CreditCard::LOCAL_CARD},
- {true, last_year.month, last_year.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::OK},
- {true, last_year.month, last_year.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::OK},
- {true, last_year.month, last_year.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::EXPIRED},
- {true, last_year.month, last_year.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::EXPIRED},
-
- // Cards that expired last month should always be updated.
- {true, last_month.month, last_month.year, CreditCard::LOCAL_CARD},
- {true, last_month.month, last_month.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::OK},
- {true, last_month.month, last_month.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::OK},
- {true, last_month.month, last_month.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::EXPIRED},
- {true, last_month.month, last_month.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::EXPIRED},
-
- // Cards that expire this month should be updated only if the server
- // status is EXPIRED.
- {false, current.month, current.year, CreditCard::LOCAL_CARD},
- {false, current.month, current.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::OK},
- {false, current.month, current.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::OK},
- {true, current.month, current.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::EXPIRED},
- {true, current.month, current.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::EXPIRED},
-
- // Cards that expire next month should be updated only if the server
- // status is EXPIRED.
- {false, next_month.month, next_month.year, CreditCard::LOCAL_CARD},
- {false, next_month.month, next_month.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::OK},
- {false, next_month.month, next_month.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::OK},
- {true, next_month.month, next_month.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::EXPIRED},
- {true, next_month.month, next_month.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::EXPIRED},
-
- // Cards that expire next year should be updated only if the server status
- // is EXPIRED.
- {false, next_year.month, next_year.year, CreditCard::LOCAL_CARD},
- {false, next_year.month, next_year.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::OK},
- {false, next_year.month, next_year.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::OK},
- {true, next_year.month, next_year.year, CreditCard::MASKED_SERVER_CARD,
- CreditCard::EXPIRED},
- {true, next_year.month, next_year.year, CreditCard::FULL_SERVER_CARD,
- CreditCard::EXPIRED},
- };
+TestingTimes testingTimes;
- for (const auto& test_case : kTestCases) {
- CreditCard card;
- card.SetExpirationMonth(test_case.month);
- card.SetExpirationYear(test_case.year);
- card.set_record_type(test_case.record_type);
- if (card.record_type() != CreditCard::LOCAL_CARD)
- card.SetServerStatus(test_case.server_status);
-
- EXPECT_EQ(test_case.should_update_expiration,
- card.ShouldUpdateExpiration(now));
- }
+TEST_P(ShouldUpdateExpirationTest, ShouldUpdateExpiration) {
+ auto test_case = GetParam();
+ CreditCard card;
+ card.SetExpirationMonth(test_case.month);
+ card.SetExpirationYear(test_case.year);
+ card.set_record_type(test_case.record_type);
+ if (card.record_type() != CreditCard::LOCAL_CARD)
+ card.SetServerStatus(test_case.server_status);
+
+ EXPECT_EQ(test_case.should_update_expiration,
+ card.ShouldUpdateExpiration(testingTimes.now_));
}
+INSTANTIATE_TEST_CASE_P(
+ CreditCardTest,
+ ShouldUpdateExpirationTest,
+ testing::Values(
+ // Cards that expired last year should always be updated.
+ ShouldUpdateExpirationTestCase{true, testingTimes.last_year_.month,
+ testingTimes.last_year_.year,
+ CreditCard::LOCAL_CARD},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.last_year_.month, testingTimes.last_year_.year,
+ CreditCard::FULL_SERVER_CARD, CreditCard::OK},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.last_year_.month, testingTimes.last_year_.year,
+ CreditCard::MASKED_SERVER_CARD, CreditCard::OK},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.last_year_.month, testingTimes.last_year_.year,
+ CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.last_year_.month, testingTimes.last_year_.year,
+ CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED},
+
+ // Cards that expired last month should always be updated.
+ ShouldUpdateExpirationTestCase{true, testingTimes.last_month_.month,
+ testingTimes.last_month_.year,
+ CreditCard::LOCAL_CARD},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.last_month_.month, testingTimes.last_month_.year,
+ CreditCard::FULL_SERVER_CARD, CreditCard::OK},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.last_month_.month, testingTimes.last_month_.year,
+ CreditCard::MASKED_SERVER_CARD, CreditCard::OK},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.last_month_.month, testingTimes.last_month_.year,
+ CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.last_month_.month, testingTimes.last_month_.year,
+ CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED},
+
+ // Cards that expire this month should be updated only if the server
+ // status is EXPIRED.
+ ShouldUpdateExpirationTestCase{false, testingTimes.current_.month,
+ testingTimes.current_.year,
+ CreditCard::LOCAL_CARD},
+ ShouldUpdateExpirationTestCase{
+ false, testingTimes.current_.month, testingTimes.current_.year,
+ CreditCard::FULL_SERVER_CARD, CreditCard::OK},
+ ShouldUpdateExpirationTestCase{
+ false, testingTimes.current_.month, testingTimes.current_.year,
+ CreditCard::MASKED_SERVER_CARD, CreditCard::OK},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.current_.month, testingTimes.current_.year,
+ CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.current_.month, testingTimes.current_.year,
+ CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED},
+
+ // Cards that expire next month should be updated only if the server
+ // status is EXPIRED.
+ ShouldUpdateExpirationTestCase{false, testingTimes.next_month_.month,
+ testingTimes.next_month_.year,
+ CreditCard::LOCAL_CARD},
+ ShouldUpdateExpirationTestCase{false, testingTimes.next_month_.month,
+ testingTimes.next_month_.year,
+ CreditCard::MASKED_SERVER_CARD,
+ CreditCard::OK},
+ ShouldUpdateExpirationTestCase{false, testingTimes.next_month_.month,
+ testingTimes.next_month_.year,
+ CreditCard::FULL_SERVER_CARD,
+ CreditCard::OK},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.next_month_.month, testingTimes.next_month_.year,
+ CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.next_month_.month, testingTimes.next_month_.year,
+ CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED},
+
+ // Cards that expire next year should be updated only if the server
+ // status is EXPIRED.
+ ShouldUpdateExpirationTestCase{false, testingTimes.next_year_.month,
+ testingTimes.next_year_.year,
+ CreditCard::LOCAL_CARD},
+ ShouldUpdateExpirationTestCase{
+ false, testingTimes.next_year_.month, testingTimes.next_year_.year,
+ CreditCard::MASKED_SERVER_CARD, CreditCard::OK},
+ ShouldUpdateExpirationTestCase{
+ false, testingTimes.next_year_.month, testingTimes.next_year_.year,
+ CreditCard::FULL_SERVER_CARD, CreditCard::OK},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.next_year_.month, testingTimes.next_year_.year,
+ CreditCard::MASKED_SERVER_CARD, CreditCard::EXPIRED},
+ ShouldUpdateExpirationTestCase{
+ true, testingTimes.next_year_.month, testingTimes.next_year_.year,
+ CreditCard::FULL_SERVER_CARD, CreditCard::EXPIRED}));
+
+// TODO(wuandy): rewriting below test with INSTANTIATE_TEST_CASE_P seems to
+// trigger a complaint on windows compilers. Removing it and revert to
+// original test for now.
+
// Test that credit card last used date suggestion can be generated correctly
// in different variations.
TEST(CreditCardTest, GetLastUsedDateForDisplay) {
« no previous file with comments | « components/autofill/core/browser/credit_card_field_unittest.cc ('k') | components/autofill/core/browser/personal_data_manager.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698