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 "components/autofill/core/browser/form_parsing/address_field.h"
6 
7 #include <memory>
8 #include <vector>
9 
10 #include "base/macros.h"
11 #include "base/memory/ptr_util.h"
12 #include "base/strings/string16.h"
13 #include "base/strings/utf_string_conversions.h"
14 #include "components/autofill/core/browser/autofill_field.h"
15 #include "components/autofill/core/browser/form_parsing/autofill_scanner.h"
16 #include "components/autofill/core/common/form_field_data.h"
17 #include "testing/gtest/include/gtest/gtest.h"
18 
19 using base::ASCIIToUTF16;
20 
21 namespace autofill {
22 
23 class AddressFieldTest : public testing::Test {
24  public:
AddressFieldTest()25   AddressFieldTest() {}
26 
27  protected:
28   std::vector<std::unique_ptr<AutofillField>> list_;
29   std::unique_ptr<AddressField> field_;
30   FieldCandidatesMap field_candidates_map_;
31 
32   // Downcast for tests.
Parse(AutofillScanner * scanner)33   static std::unique_ptr<AddressField> Parse(AutofillScanner* scanner) {
34     std::unique_ptr<FormField> field = AddressField::Parse(scanner, nullptr);
35     return std::unique_ptr<AddressField>(
36         static_cast<AddressField*>(field.release()));
37   }
38 
39  private:
40   DISALLOW_COPY_AND_ASSIGN(AddressFieldTest);
41 };
42 
TEST_F(AddressFieldTest,Empty)43 TEST_F(AddressFieldTest, Empty) {
44   AutofillScanner scanner(list_);
45   field_ = Parse(&scanner);
46   ASSERT_EQ(nullptr, field_.get());
47 }
48 
TEST_F(AddressFieldTest,NonParse)49 TEST_F(AddressFieldTest, NonParse) {
50   list_.push_back(std::make_unique<AutofillField>());
51   AutofillScanner scanner(list_);
52   field_ = Parse(&scanner);
53   ASSERT_EQ(nullptr, field_.get());
54 }
55 
TEST_F(AddressFieldTest,ParseOneLineAddress)56 TEST_F(AddressFieldTest, ParseOneLineAddress) {
57   FormFieldData field;
58   field.form_control_type = "text";
59 
60   field.label = ASCIIToUTF16("Address");
61   field.name = ASCIIToUTF16("address");
62   list_.push_back(
63       std::make_unique<AutofillField>(field, ASCIIToUTF16("addr1")));
64 
65   AutofillScanner scanner(list_);
66   field_ = Parse(&scanner);
67   ASSERT_NE(nullptr, field_.get());
68   field_->AddClassifications(&field_candidates_map_);
69   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("addr1")) !=
70               field_candidates_map_.end());
71   EXPECT_EQ(ADDRESS_HOME_LINE1,
72             field_candidates_map_[ASCIIToUTF16("addr1")].BestHeuristicType());
73 }
74 
TEST_F(AddressFieldTest,ParseTwoLineAddress)75 TEST_F(AddressFieldTest, ParseTwoLineAddress) {
76   FormFieldData field;
77   field.form_control_type = "text";
78 
79   field.label = ASCIIToUTF16("Address");
80   field.name = ASCIIToUTF16("address");
81   list_.push_back(
82       std::make_unique<AutofillField>(field, ASCIIToUTF16("addr1")));
83 
84   field.label = base::string16();
85   field.name = ASCIIToUTF16("address2");
86   list_.push_back(
87       std::make_unique<AutofillField>(field, ASCIIToUTF16("addr2")));
88 
89   AutofillScanner scanner(list_);
90   field_ = Parse(&scanner);
91   ASSERT_NE(nullptr, field_.get());
92   field_->AddClassifications(&field_candidates_map_);
93   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("addr1")) !=
94               field_candidates_map_.end());
95   EXPECT_EQ(ADDRESS_HOME_LINE1,
96             field_candidates_map_[ASCIIToUTF16("addr1")].BestHeuristicType());
97   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("addr2")) !=
98               field_candidates_map_.end());
99   EXPECT_EQ(ADDRESS_HOME_LINE2,
100             field_candidates_map_[ASCIIToUTF16("addr2")].BestHeuristicType());
101 }
102 
TEST_F(AddressFieldTest,ParseThreeLineAddress)103 TEST_F(AddressFieldTest, ParseThreeLineAddress) {
104   FormFieldData field;
105   field.form_control_type = "text";
106 
107   field.label = ASCIIToUTF16("Address Line1");
108   field.name = ASCIIToUTF16("Address1");
109   list_.push_back(
110       std::make_unique<AutofillField>(field, ASCIIToUTF16("addr1")));
111 
112   field.label = ASCIIToUTF16("Address Line2");
113   field.name = ASCIIToUTF16("Address2");
114   list_.push_back(
115       std::make_unique<AutofillField>(field, ASCIIToUTF16("addr2")));
116 
117   field.label = ASCIIToUTF16("Address Line3");
118   field.name = ASCIIToUTF16("Address3");
119   list_.push_back(
120       std::make_unique<AutofillField>(field, ASCIIToUTF16("addr3")));
121 
122   AutofillScanner scanner(list_);
123   field_ = Parse(&scanner);
124   ASSERT_NE(nullptr, field_.get());
125   field_->AddClassifications(&field_candidates_map_);
126   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("addr1")) !=
127               field_candidates_map_.end());
128   EXPECT_EQ(ADDRESS_HOME_LINE1,
129             field_candidates_map_[ASCIIToUTF16("addr1")].BestHeuristicType());
130   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("addr2")) !=
131               field_candidates_map_.end());
132   EXPECT_EQ(ADDRESS_HOME_LINE2,
133             field_candidates_map_[ASCIIToUTF16("addr2")].BestHeuristicType());
134   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("addr3")) !=
135               field_candidates_map_.end());
136   EXPECT_EQ(ADDRESS_HOME_LINE3,
137             field_candidates_map_[ASCIIToUTF16("addr3")].BestHeuristicType());
138 }
139 
TEST_F(AddressFieldTest,ParseStreetAddressFromTextArea)140 TEST_F(AddressFieldTest, ParseStreetAddressFromTextArea) {
141   FormFieldData field;
142   field.form_control_type = "textarea";
143 
144   field.label = ASCIIToUTF16("Address");
145   field.name = ASCIIToUTF16("address");
146   list_.push_back(std::make_unique<AutofillField>(field, ASCIIToUTF16("addr")));
147 
148   AutofillScanner scanner(list_);
149   field_ = Parse(&scanner);
150   ASSERT_NE(nullptr, field_.get());
151   field_->AddClassifications(&field_candidates_map_);
152   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("addr")) !=
153               field_candidates_map_.end());
154   EXPECT_EQ(ADDRESS_HOME_STREET_ADDRESS,
155             field_candidates_map_[ASCIIToUTF16("addr")].BestHeuristicType());
156 }
157 
TEST_F(AddressFieldTest,ParseCity)158 TEST_F(AddressFieldTest, ParseCity) {
159   FormFieldData field;
160   field.form_control_type = "text";
161 
162   field.label = ASCIIToUTF16("City");
163   field.name = ASCIIToUTF16("city");
164   list_.push_back(
165       std::make_unique<AutofillField>(field, ASCIIToUTF16("city1")));
166 
167   AutofillScanner scanner(list_);
168   field_ = Parse(&scanner);
169   ASSERT_NE(nullptr, field_.get());
170   field_->AddClassifications(&field_candidates_map_);
171   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("city1")) !=
172               field_candidates_map_.end());
173   EXPECT_EQ(ADDRESS_HOME_CITY,
174             field_candidates_map_[ASCIIToUTF16("city1")].BestHeuristicType());
175 }
176 
TEST_F(AddressFieldTest,ParseState)177 TEST_F(AddressFieldTest, ParseState) {
178   FormFieldData field;
179   field.form_control_type = "text";
180 
181   field.label = ASCIIToUTF16("State");
182   field.name = ASCIIToUTF16("state");
183   list_.push_back(
184       std::make_unique<AutofillField>(field, ASCIIToUTF16("state1")));
185 
186   AutofillScanner scanner(list_);
187   field_ = Parse(&scanner);
188   ASSERT_NE(nullptr, field_.get());
189   field_->AddClassifications(&field_candidates_map_);
190   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("state1")) !=
191               field_candidates_map_.end());
192   EXPECT_EQ(ADDRESS_HOME_STATE,
193             field_candidates_map_[ASCIIToUTF16("state1")].BestHeuristicType());
194 }
195 
TEST_F(AddressFieldTest,ParseZip)196 TEST_F(AddressFieldTest, ParseZip) {
197   FormFieldData field;
198   field.form_control_type = "text";
199 
200   field.label = ASCIIToUTF16("Zip");
201   field.name = ASCIIToUTF16("zip");
202   list_.push_back(std::make_unique<AutofillField>(field, ASCIIToUTF16("zip1")));
203 
204   AutofillScanner scanner(list_);
205   field_ = Parse(&scanner);
206   ASSERT_NE(nullptr, field_.get());
207   field_->AddClassifications(&field_candidates_map_);
208   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("zip1")) !=
209               field_candidates_map_.end());
210   EXPECT_EQ(ADDRESS_HOME_ZIP,
211             field_candidates_map_[ASCIIToUTF16("zip1")].BestHeuristicType());
212 }
213 
TEST_F(AddressFieldTest,ParseStateAndZipOneLabel)214 TEST_F(AddressFieldTest, ParseStateAndZipOneLabel) {
215   FormFieldData field;
216   field.form_control_type = "text";
217 
218   field.label = ASCIIToUTF16("State/Province, Zip/Postal Code");
219   field.name = ASCIIToUTF16("state");
220   list_.push_back(
221       std::make_unique<AutofillField>(field, ASCIIToUTF16("state")));
222 
223   field.label = ASCIIToUTF16("State/Province, Zip/Postal Code");
224   field.name = ASCIIToUTF16("zip");
225   list_.push_back(std::make_unique<AutofillField>(field, ASCIIToUTF16("zip")));
226 
227   AutofillScanner scanner(list_);
228   field_ = Parse(&scanner);
229   ASSERT_NE(nullptr, field_.get());
230   field_->AddClassifications(&field_candidates_map_);
231   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("state")) !=
232               field_candidates_map_.end());
233   EXPECT_EQ(ADDRESS_HOME_STATE,
234             field_candidates_map_[ASCIIToUTF16("state")].BestHeuristicType());
235   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("zip")) !=
236               field_candidates_map_.end());
237   EXPECT_EQ(ADDRESS_HOME_ZIP,
238             field_candidates_map_[ASCIIToUTF16("zip")].BestHeuristicType());
239 }
240 
TEST_F(AddressFieldTest,ParseCountry)241 TEST_F(AddressFieldTest, ParseCountry) {
242   FormFieldData field;
243   field.form_control_type = "text";
244 
245   field.label = ASCIIToUTF16("Country");
246   field.name = ASCIIToUTF16("country");
247   list_.push_back(
248       std::make_unique<AutofillField>(field, ASCIIToUTF16("country1")));
249 
250   AutofillScanner scanner(list_);
251   field_ = Parse(&scanner);
252   ASSERT_NE(nullptr, field_.get());
253   field_->AddClassifications(&field_candidates_map_);
254   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("country1")) !=
255               field_candidates_map_.end());
256   EXPECT_EQ(
257       ADDRESS_HOME_COUNTRY,
258       field_candidates_map_[ASCIIToUTF16("country1")].BestHeuristicType());
259 }
260 
TEST_F(AddressFieldTest,ParseCompany)261 TEST_F(AddressFieldTest, ParseCompany) {
262   FormFieldData field;
263   field.form_control_type = "text";
264 
265   field.label = ASCIIToUTF16("Company");
266   field.name = ASCIIToUTF16("company");
267   list_.push_back(
268       std::make_unique<AutofillField>(field, ASCIIToUTF16("company1")));
269 
270   AutofillScanner scanner(list_);
271   field_ = Parse(&scanner);
272   ASSERT_NE(nullptr, field_.get());
273   field_->AddClassifications(&field_candidates_map_);
274   ASSERT_TRUE(field_candidates_map_.find(ASCIIToUTF16("company1")) !=
275               field_candidates_map_.end());
276   EXPECT_EQ(
277       COMPANY_NAME,
278       field_candidates_map_[ASCIIToUTF16("company1")].BestHeuristicType());
279 }
280 
281 }  // namespace autofill
282