[Web Payments] Common Payments validation

components/payments/payments_validators_test.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/payments/PaymentsValidators.h"
+#include "components/payments/payments_validators.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "wtf/text/WTFString.h"
 #include <ostream>  // NOLINT
 
 namespace blink {
 namespace {
 
 struct CurrencyCodeTestCase {
   CurrencyCodeTestCase(const char* code, const char* system, bool expectedValid)
       : code(code), system(system), expectedValid(expectedValid) {}
   ~CurrencyCodeTestCase() {}
 
@@ skipping 15 matching lines @@
 
 const char* longString2049() {
   static char longString[2050];
   for (int i = 0; i < 2049; i++)
     longString[i] = 'a';
   longString[2049] = '\0';
   return longString;
 }
 
 TEST_P(PaymentsCurrencyValidatorTest, IsValidCurrencyCodeFormat) {
-  String errorMessage;
+  std::string errorMessage;
   EXPECT_EQ(GetParam().expectedValid,
-            PaymentsValidators::isValidCurrencyCodeFormat(
+            payments::PaymentsValidators::isValidCurrencyCodeFormat(
                 GetParam().code, GetParam().system, &errorMessage))
       << errorMessage;
-  EXPECT_EQ(GetParam().expectedValid, errorMessage.isEmpty()) << errorMessage;
+  EXPECT_EQ(GetParam().expectedValid, errorMessage.empty()) << errorMessage;
 
   EXPECT_EQ(GetParam().expectedValid,
-            PaymentsValidators::isValidCurrencyCodeFormat(
+            payments::PaymentsValidators::isValidCurrencyCodeFormat(
                 GetParam().code, GetParam().system, nullptr));
 }
 
 INSTANTIATE_TEST_CASE_P(
     CurrencyCodes,
     PaymentsCurrencyValidatorTest,
     testing::Values(
         // The most common identifiers are three-letter alphabetic codes as
         // defined by [ISO4217] (for example, "USD" for US Dollars).
         // |system| is a URL that indicates the currency system that the
@@ skipping 32 matching lines @@
 
 std::ostream& operator<<(std::ostream& out, const TestCase& testCase) {
   out << "'" << testCase.input << "' is expected to be "
       << (testCase.expectedValid ? "valid" : "invalid");
   return out;
 }
 
 class PaymentsAmountValidatorTest : public testing::TestWithParam<TestCase> {};
 
 TEST_P(PaymentsAmountValidatorTest, IsValidAmountFormat) {
-  String errorMessage;
-  EXPECT_EQ(GetParam().expectedValid, PaymentsValidators::isValidAmountFormat(
-                                          GetParam().input, &errorMessage))
+  std::string errorMessage;
+  EXPECT_EQ(GetParam().expectedValid,
+            payments::PaymentsValidators::isValidAmountFormat(GetParam().input,
+                                                              &errorMessage))
       << errorMessage;
-  EXPECT_EQ(GetParam().expectedValid, errorMessage.isEmpty()) << errorMessage;
+  EXPECT_EQ(GetParam().expectedValid, errorMessage.empty()) << errorMessage;
 
   EXPECT_EQ(GetParam().expectedValid,
-            PaymentsValidators::isValidAmountFormat(GetParam().input, nullptr));
+            payments::PaymentsValidators::isValidAmountFormat(GetParam().input,
+                                                              nullptr));
 }
 
 INSTANTIATE_TEST_CASE_P(
     Amounts,
     PaymentsAmountValidatorTest,
     testing::Values(TestCase("0", true),
                     TestCase("-0", true),
                     TestCase("1", true),
                     TestCase("10", true),
                     TestCase("-3", true),
@@ skipping 15 matching lines @@
                     TestCase("-10.", false),
                     TestCase("-.99", false),
                     TestCase("10-", false),
                     TestCase("1-0", false),
                     TestCase("1.0.0", false),
                     TestCase("1/3", false)));
 
 class PaymentsRegionValidatorTest : public testing::TestWithParam<TestCase> {};
 
 TEST_P(PaymentsRegionValidatorTest, IsValidCountryCodeFormat) {
-  String errorMessage;
+  std::string errorMessage;
   EXPECT_EQ(GetParam().expectedValid,
-            PaymentsValidators::isValidCountryCodeFormat(GetParam().input,
-                                                         &errorMessage))
+            payments::PaymentsValidators::isValidCountryCodeFormat(
+                GetParam().input, &errorMessage))
       << errorMessage;
-  EXPECT_EQ(GetParam().expectedValid, errorMessage.isEmpty()) << errorMessage;
+  EXPECT_EQ(GetParam().expectedValid, errorMessage.empty()) << errorMessage;
 
-  EXPECT_EQ(
-      GetParam().expectedValid,
-      PaymentsValidators::isValidCountryCodeFormat(GetParam().input, nullptr));
+  EXPECT_EQ(GetParam().expectedValid,
+            payments::PaymentsValidators::isValidCountryCodeFormat(
+                GetParam().input, nullptr));
 }
 
 INSTANTIATE_TEST_CASE_P(CountryCodes,
                         PaymentsRegionValidatorTest,
                         testing::Values(TestCase("US", true),
                                         // Invalid country code formats
                                         TestCase("U1", false),
                                         TestCase("U", false),
                                         TestCase("us", false),
                                         TestCase("USA", false),
                                         TestCase("", false)));
 
 class PaymentsLanguageValidatorTest : public testing::TestWithParam<TestCase> {
 };
 
 TEST_P(PaymentsLanguageValidatorTest, IsValidLanguageCodeFormat) {
-  String errorMessage;
+  std::string errorMessage;
   EXPECT_EQ(GetParam().expectedValid,
-            PaymentsValidators::isValidLanguageCodeFormat(GetParam().input,
-                                                          &errorMessage))
+            payments::PaymentsValidators::isValidLanguageCodeFormat(
+                GetParam().input, &errorMessage))
       << errorMessage;
-  EXPECT_EQ(GetParam().expectedValid, errorMessage.isEmpty()) << errorMessage;
+  EXPECT_EQ(GetParam().expectedValid, errorMessage.empty()) << errorMessage;
 
-  EXPECT_EQ(
-      GetParam().expectedValid,
-      PaymentsValidators::isValidLanguageCodeFormat(GetParam().input, nullptr));
+  EXPECT_EQ(GetParam().expectedValid,
+            payments::PaymentsValidators::isValidLanguageCodeFormat(
+                GetParam().input, nullptr));
 }
 
 INSTANTIATE_TEST_CASE_P(LanguageCodes,
                         PaymentsLanguageValidatorTest,
                         testing::Values(TestCase("", true),
                                         TestCase("en", true),
                                         TestCase("eng", true),
                                         // Invalid language code formats
                                         TestCase("e1", false),
                                         TestCase("en1", false),
                                         TestCase("e", false),
                                         TestCase("engl", false),
                                         TestCase("EN", false)));
 
 class PaymentsScriptValidatorTest : public testing::TestWithParam<TestCase> {};
 
 TEST_P(PaymentsScriptValidatorTest, IsValidScriptCodeFormat) {
-  String errorMessage;
+  std::string errorMessage;
   EXPECT_EQ(GetParam().expectedValid,
-            PaymentsValidators::isValidScriptCodeFormat(GetParam().input,
-                                                        &errorMessage))
+            payments::PaymentsValidators::isValidScriptCodeFormat(
+                GetParam().input, &errorMessage))
       << errorMessage;
-  EXPECT_EQ(GetParam().expectedValid, errorMessage.isEmpty()) << errorMessage;
+  EXPECT_EQ(GetParam().expectedValid, errorMessage.empty()) << errorMessage;
 
-  EXPECT_EQ(
-      GetParam().expectedValid,
-      PaymentsValidators::isValidScriptCodeFormat(GetParam().input, nullptr));
+  EXPECT_EQ(GetParam().expectedValid,
+            payments::PaymentsValidators::isValidScriptCodeFormat(
+                GetParam().input, nullptr));
 }
 
 INSTANTIATE_TEST_CASE_P(ScriptCodes,
                         PaymentsScriptValidatorTest,
                         testing::Values(TestCase("", true),
                                         TestCase("Latn", true),
                                         // Invalid script code formats
                                         TestCase("Lat1", false),
                                         TestCase("1lat", false),
                                         TestCase("Latin", false),
@@ skipping 15 matching lines @@
   const char* countryCode;
   const char* languageCode;
   const char* scriptCode;
   bool expectedValid;
 };
 
 class PaymentsShippingAddressValidatorTest
     : public testing::TestWithParam<ShippingAddressTestCase> {};
 
 TEST_P(PaymentsShippingAddressValidatorTest, IsValidShippingAddress) {
-  mojom::blink::PaymentAddressPtr address = mojom::blink::PaymentAddress::New();
+  blink::mojom::PaymentAddressPtr address = blink::mojom::PaymentAddress::New();
   address->country = GetParam().countryCode;
   address->language_code = GetParam().languageCode;
   address->script_code = GetParam().scriptCode;
 
-  String errorMessage;
+  std::string errorMessage;
   EXPECT_EQ(GetParam().expectedValid,
-            PaymentsValidators::isValidShippingAddress(address, &errorMessage))
+            payments::PaymentsValidators::isValidShippingAddress(address,
+                                                                 &errorMessage))
       << errorMessage;
-  EXPECT_EQ(GetParam().expectedValid, errorMessage.isEmpty()) << errorMessage;
+  EXPECT_EQ(GetParam().expectedValid, errorMessage.empty()) << errorMessage;
 
-  EXPECT_EQ(GetParam().expectedValid,
-            PaymentsValidators::isValidShippingAddress(address, nullptr));
+  EXPECT_EQ(
+      GetParam().expectedValid,
+      payments::PaymentsValidators::isValidShippingAddress(address, nullptr));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ShippingAddresses,
     PaymentsShippingAddressValidatorTest,
     testing::Values(
         ShippingAddressTestCase("US", "en", "Latn", true),
         ShippingAddressTestCase("US", "en", "", true),
         ShippingAddressTestCase("US", "", "", true),
         // Invalid shipping addresses
         ShippingAddressTestCase("", "", "", false),
         ShippingAddressTestCase("InvalidCountryCode", "", "", false),
         ShippingAddressTestCase("US", "InvalidLanguageCode", "", false),
         ShippingAddressTestCase("US", "en", "InvalidScriptCode", false),
         ShippingAddressTestCase("US", "", "Latn", false)));
 
 }  // namespace
 }  // namespace blink