1 // Copyright (C) 2014 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language_code governing permissions and
13 // limitations under the License.
14 
15 #include <libaddressinput/address_formatter.h>
16 
17 #include <libaddressinput/address_data.h>
18 
19 #include <string>
20 #include <vector>
21 
22 #include <gtest/gtest.h>
23 
24 namespace {
25 
26 using i18n::addressinput::AddressData;
27 using i18n::addressinput::GetFormattedNationalAddress;
28 using i18n::addressinput::GetFormattedNationalAddressLine;
29 using i18n::addressinput::GetStreetAddressLinesAsSingleLine;
30 
TEST(AddressFormatterTest,GetStreetAddressLinesAsSingleLine_EmptyAddress)31 TEST(AddressFormatterTest, GetStreetAddressLinesAsSingleLine_EmptyAddress) {
32   AddressData address;
33   std::string result;
34   GetStreetAddressLinesAsSingleLine(address, &result);
35   EXPECT_TRUE(result.empty());
36 }
37 
TEST(AddressFormatterTest,GetStreetAddressLinesAsSingleLine_1Line)38 TEST(AddressFormatterTest, GetStreetAddressLinesAsSingleLine_1Line) {
39   AddressData address;
40   address.region_code = "US";  // Not used.
41   address.address_line.emplace_back("Line 1");
42 
43   std::string result;
44   GetStreetAddressLinesAsSingleLine(address, &result);
45   EXPECT_EQ("Line 1", result);
46 
47   // Setting the language_code, with one line, shouldn't affect anything.
48   address.language_code = "en";
49   GetStreetAddressLinesAsSingleLine(address, &result);
50   EXPECT_EQ("Line 1", result);
51 
52   address.language_code = "zh-Hans";
53   GetStreetAddressLinesAsSingleLine(address, &result);
54   EXPECT_EQ("Line 1", result);
55 }
56 
TEST(AddressFormatterTest,GetStreetAddressLinesAsSingleLine_2Lines)57 TEST(AddressFormatterTest, GetStreetAddressLinesAsSingleLine_2Lines) {
58   AddressData address;
59   address.region_code = "US";  // Not used.
60   address.address_line.emplace_back("Line 1");
61   address.address_line.emplace_back("Line 2");
62 
63   std::string result;
64   GetStreetAddressLinesAsSingleLine(address, &result);
65   // Default separator if no language_code specified: ", "
66   EXPECT_EQ("Line 1, Line 2", result);
67 
68   address.language_code = "en";
69   GetStreetAddressLinesAsSingleLine(address, &result);
70   EXPECT_EQ("Line 1, Line 2", result);
71 
72   address.language_code = "zh-Hans";
73   GetStreetAddressLinesAsSingleLine(address, &result);
74   // Chinese has no separator.
75   EXPECT_EQ("Line 1Line 2", result);
76 
77   address.language_code = "ko";
78   GetStreetAddressLinesAsSingleLine(address, &result);
79   EXPECT_EQ("Line 1 Line 2", result);
80 
81   address.language_code = "ar";
82   GetStreetAddressLinesAsSingleLine(address, &result);
83   EXPECT_EQ(u8"Line 1، Line 2", result);
84 }
85 
TEST(AddressFormatterTest,GetStreetAddressLinesAsSingleLine_5Lines)86 TEST(AddressFormatterTest, GetStreetAddressLinesAsSingleLine_5Lines) {
87   AddressData address;
88   address.region_code = "US";  // Not used.
89   address.address_line.emplace_back("Line 1");
90   address.address_line.emplace_back("Line 2");
91   address.address_line.emplace_back("Line 3");
92   address.address_line.emplace_back("Line 4");
93   address.address_line.emplace_back("Line 5");
94   address.language_code = "fr";
95 
96   std::string result;
97   GetStreetAddressLinesAsSingleLine(address, &result);
98   EXPECT_EQ(result, "Line 1, Line 2, Line 3, Line 4, Line 5");
99 }
100 
TEST(AddressFormatterTest,GetFormattedNationalAddressLocalLanguage)101 TEST(AddressFormatterTest, GetFormattedNationalAddressLocalLanguage) {
102   AddressData address;
103   address.region_code = "NZ";
104   address.address_line.emplace_back("Rotopapa");
105   address.address_line.emplace_back("Irwell 3RD");
106   address.postal_code = "8704";
107   address.locality = "Leeston";
108 
109   std::vector<std::string> expected;
110   expected.emplace_back("Rotopapa");
111   expected.emplace_back("Irwell 3RD");
112   expected.emplace_back("Leeston 8704");
113 
114   std::vector<std::string> lines;
115   GetFormattedNationalAddress(address, &lines);
116   EXPECT_EQ(expected, lines);
117 
118   // Should be the same result no matter what the language_code is. We choose an
119   // unlikely language_code code to illustrate this.
120   address.language_code = "en-Latn-CN";
121 
122   lines.clear();
123   GetFormattedNationalAddress(address, &lines);
124   EXPECT_EQ(expected, lines);
125 
126   std::string one_line;
127   GetFormattedNationalAddressLine(address, &one_line);
128   EXPECT_EQ("Rotopapa, Irwell 3RD, Leeston 8704", one_line);
129 }
130 
TEST(AddressFormatterTest,GetFormattedNationalAddressLatinFormat)131 TEST(AddressFormatterTest, GetFormattedNationalAddressLatinFormat) {
132   static const char kTaiwanCity[] = u8"大安區";
133   static const char kTaiwanAdmin[] = u8"台北市";
134   static const char kTaiwanStreetLine[] = u8"台灣信義路三段33號";
135   static const char kPostalCode[] = "106";
136 
137   AddressData address;
138   address.region_code = "TW";
139   address.address_line.emplace_back(kTaiwanStreetLine);
140   address.postal_code = kPostalCode;
141   address.locality = kTaiwanCity;
142   address.administrative_area = kTaiwanAdmin;
143   address.language_code = "zh-Hant";
144 
145   std::vector<std::string> expected;
146   expected.emplace_back(kPostalCode);
147   expected.push_back(std::string(kTaiwanAdmin).append(kTaiwanCity));
148   expected.emplace_back(kTaiwanStreetLine);
149 
150   std::vector<std::string> lines;
151   GetFormattedNationalAddress(address, &lines);
152   EXPECT_EQ(expected, lines);
153 
154   std::string one_line;
155   GetFormattedNationalAddressLine(address, &one_line);
156   // No separators expected for Chinese.
157   EXPECT_EQ(std::string(kPostalCode)
158                 .append(kTaiwanAdmin)
159                 .append(kTaiwanCity)
160                 .append(kTaiwanStreetLine),
161             one_line);
162 
163   // Changing to the Latin variant will change the output.
164   AddressData latin_address;
165   latin_address.region_code = "TW";
166   latin_address.address_line.emplace_back("No. 33, Section 3 Xinyi Rd");
167   latin_address.postal_code = kPostalCode;
168   latin_address.locality = "Da-an District";
169   latin_address.administrative_area = "Taipei City";
170   latin_address.language_code = "zh-Latn";
171 
172   std::vector<std::string> expected_latin;
173   expected_latin.emplace_back("No. 33, Section 3 Xinyi Rd");
174   expected_latin.emplace_back("Da-an District, Taipei City 106");
175 
176   lines.clear();
177   GetFormattedNationalAddress(latin_address, &lines);
178   EXPECT_EQ(expected_latin, lines);
179 
180   GetFormattedNationalAddressLine(latin_address, &one_line);
181   // We expect ", " as the new-line replacements for zh-Latn.
182   EXPECT_EQ("No. 33, Section 3 Xinyi Rd, Da-an District, Taipei City 106",
183             one_line);
184 }
185 
TEST(AddressFormatterTest,GetFormattedNationalAddressMultilingualCountry)186 TEST(AddressFormatterTest, GetFormattedNationalAddressMultilingualCountry) {
187   AddressData address;
188   address.region_code = "CA";
189   address.address_line.emplace_back("5 Rue du Tresor");
190   address.address_line.emplace_back("Apt. 4");
191   address.administrative_area = "QC";
192   address.postal_code = "G1R 123";
193   address.locality = "Montmagny";
194   address.language_code = "fr";
195 
196   std::vector<std::string> expected;
197   expected.emplace_back("5 Rue du Tresor");
198   expected.emplace_back("Apt. 4");
199   expected.emplace_back("Montmagny QC G1R 123");
200 
201   std::vector<std::string> lines;
202   GetFormattedNationalAddress(address, &lines);
203   EXPECT_EQ(expected, lines);
204 }
205 
TEST(AddressFormatterTest,GetFormattedNationalAddress_InlineStreetAddress)206 TEST(AddressFormatterTest, GetFormattedNationalAddress_InlineStreetAddress) {
207   AddressData address;
208   address.region_code = "CI";
209   address.address_line.emplace_back("32 Boulevard Carde");
210   address.locality = "Abidjan";
211   address.sorting_code = "64";
212 
213   std::vector<std::string> expected;
214   expected.emplace_back("64 32 Boulevard Carde Abidjan 64");
215 
216   std::vector<std::string> lines;
217   GetFormattedNationalAddress(address, &lines);
218   EXPECT_EQ(expected, lines);
219 }
220 
TEST(AddressFormatterTest,GetFormattedNationalAddressMissingFields_LiteralsAroundField)221 TEST(AddressFormatterTest,
222      GetFormattedNationalAddressMissingFields_LiteralsAroundField) {
223   AddressData address;
224   address.region_code = "CH";
225   std::vector<std::string> expected;
226   std::vector<std::string> lines;
227   GetFormattedNationalAddress(address, &lines);
228   EXPECT_EQ(expected, lines);
229 
230   address.locality = "Zurich";
231   expected.emplace_back("Zurich");
232   GetFormattedNationalAddress(address, &lines);
233   EXPECT_EQ(expected, lines);
234 
235   address.postal_code = "8001";
236   expected.back().assign("CH-8001 Zurich");
237   GetFormattedNationalAddress(address, &lines);
238   EXPECT_EQ(expected, lines);
239 
240   address.locality.clear();
241   expected.back().assign("CH-8001");
242   GetFormattedNationalAddress(address, &lines);
243   EXPECT_EQ(expected, lines);
244 }
245 
TEST(AddressFormatterTest,GetFormattedNationalAddressMissingFields_LiteralsBetweenFields)246 TEST(AddressFormatterTest,
247      GetFormattedNationalAddressMissingFields_LiteralsBetweenFields) {
248   AddressData address;
249   address.region_code = "US";
250   std::vector<std::string> expected;
251   std::vector<std::string> lines;
252   GetFormattedNationalAddress(address, &lines);
253   EXPECT_EQ(expected, lines);
254 
255   address.administrative_area = "CA";
256   expected.emplace_back("CA");
257   GetFormattedNationalAddress(address, &lines);
258   EXPECT_EQ(expected, lines);
259 
260   address.locality = "Los Angeles";
261   expected.back().assign("Los Angeles, CA");
262   GetFormattedNationalAddress(address, &lines);
263   EXPECT_EQ(expected, lines);
264 
265   address.postal_code = "90291";
266   expected.back().assign("Los Angeles, CA 90291");
267   GetFormattedNationalAddress(address, &lines);
268   EXPECT_EQ(expected, lines);
269 
270   address.administrative_area.clear();
271   expected.back().assign("Los Angeles 90291");
272   GetFormattedNationalAddress(address, &lines);
273   EXPECT_EQ(expected, lines);
274 
275   address.locality.clear();
276   address.administrative_area = "CA";
277   expected.back().assign("CA 90291");
278   GetFormattedNationalAddress(address, &lines);
279   EXPECT_EQ(expected, lines);
280 }
281 
TEST(AddressFormatterTest,GetFormattedNationalAddressMissingFields_LiteralOnSeparateLine)282 TEST(AddressFormatterTest,
283      GetFormattedNationalAddressMissingFields_LiteralOnSeparateLine) {
284   AddressData address;
285   address.region_code = "AX";
286   std::vector<std::string> expected;
287   expected.emplace_back(u8"ÅLAND");
288   std::vector<std::string> lines;
289   GetFormattedNationalAddress(address, &lines);
290   EXPECT_EQ(expected, lines);
291 
292   address.locality = "City";
293   expected.emplace(expected.begin(), "City");
294   GetFormattedNationalAddress(address, &lines);
295   EXPECT_EQ(expected, lines);
296 
297   address.postal_code = "123";
298   expected.front().assign("AX-123 City");
299   GetFormattedNationalAddress(address, &lines);
300   EXPECT_EQ(expected, lines);
301 }
302 
TEST(AddressFormatterTest,GetFormattedNationalAddressMissingFields_LiteralBeforeField)303 TEST(AddressFormatterTest,
304      GetFormattedNationalAddressMissingFields_LiteralBeforeField) {
305   AddressData address;
306   address.region_code = "JP";
307   address.language_code = "ja";
308   std::vector<std::string> expected;
309   std::vector<std::string> lines;
310   GetFormattedNationalAddress(address, &lines);
311   EXPECT_EQ(expected, lines);
312 
313   address.postal_code = "123";
314   expected.emplace_back(u8"〒123");
315   GetFormattedNationalAddress(address, &lines);
316   EXPECT_EQ(expected, lines);
317 
318   address.administrative_area = "Prefecture";
319   expected.emplace_back("Prefecture");
320   GetFormattedNationalAddress(address, &lines);
321   EXPECT_EQ(expected, lines);
322 
323   address.postal_code.clear();
324   expected.erase(expected.begin());
325   GetFormattedNationalAddress(address, &lines);
326   EXPECT_EQ(expected, lines);
327 }
328 
TEST(AddressFormatterTest,GetFormattedNationalAddress_LiteralBeforeOneAddressLine)329 TEST(AddressFormatterTest,
330      GetFormattedNationalAddress_LiteralBeforeOneAddressLine) {
331   AddressData address;
332   address.region_code = "JP";
333   address.language_code = "ja_Latn";
334   address.administrative_area = "Tokyo";
335   address.address_line = {"Roppongi Hills"};
336   std::vector<std::string> expected;
337   expected.emplace_back("Roppongi Hills, Tokyo");
338   std::vector<std::string> lines;
339   GetFormattedNationalAddress(address, &lines);
340   EXPECT_EQ(expected, lines);
341 }
342 
TEST(AddressFormatterTest,GetFormattedNationalAddress_LiteralBeforeTwoAddressLines)343 TEST(AddressFormatterTest,
344      GetFormattedNationalAddress_LiteralBeforeTwoAddressLines) {
345   AddressData address;
346   address.region_code = "JP";
347   address.language_code = "ja_Latn";
348   address.administrative_area = "Tokyo";
349   address.address_line = {"Roppongi Hills", "Mori Tower"};
350   std::vector<std::string> expected;
351   expected.emplace_back("Roppongi Hills");
352   expected.emplace_back("Mori Tower, Tokyo");
353   std::vector<std::string> lines;
354   GetFormattedNationalAddress(address, &lines);
355   EXPECT_EQ(expected, lines);
356 }
357 
TEST(AddressFormatterTest,GetFormattedNationalAddressMissingFields_DuplicateField)358 TEST(AddressFormatterTest,
359      GetFormattedNationalAddressMissingFields_DuplicateField) {
360   AddressData address;
361   address.region_code = "CI";
362   std::vector<std::string> expected;
363   std::vector<std::string> lines;
364   GetFormattedNationalAddress(address, &lines);
365   EXPECT_EQ(expected, lines);
366 
367   address.sorting_code = "123";
368   expected.emplace_back("123 123");
369   GetFormattedNationalAddress(address, &lines);
370   EXPECT_EQ(expected, lines);
371 
372   address.address_line.emplace_back("456 Main St");
373   expected.back().assign("123 456 Main St 123");
374   GetFormattedNationalAddress(address, &lines);
375   EXPECT_EQ(expected, lines);
376 
377   address.locality = "Yamoussoukro";
378   expected.back().assign("123 456 Main St Yamoussoukro 123");
379   GetFormattedNationalAddress(address, &lines);
380   EXPECT_EQ(expected, lines);
381 
382   address.sorting_code.erase();
383   expected.back().assign("456 Main St Yamoussoukro");
384   GetFormattedNationalAddress(address, &lines);
385   EXPECT_EQ(expected, lines);
386 
387   address.address_line.clear();
388   expected.back().assign("Yamoussoukro");
389   GetFormattedNationalAddress(address, &lines);
390   EXPECT_EQ(expected, lines);
391 }
392 
393 }  // namespace
394