1/*
2 * Copyright (C) 2010 Google Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.i18n.addressinput;
18
19import junit.framework.TestCase;
20
21/**
22 * Spot check the standard data set for various cases of interest. This is not an exhaustive test.
23 */
24public class StandardAddressVerifierTest extends TestCase {
25
26    private AddressProblems problems = new AddressProblems();
27    private StandardAddressVerifier verifier;
28
29    @Override
30    protected void setUp() {
31        problems.clear();
32        verifier = new StandardAddressVerifier(new FieldVerifier(new ClientData(new CacheData())),
33                                               StandardChecks.PROBLEM_MAP);
34    }
35
36    public void testUnitedStatesOk() {
37        AddressData addr = new AddressData.Builder().setCountry("US")
38                                                    .setAdminArea("CA")
39                                                    .setLocality("Mountain View")
40                                                    .setAddress("1234 Somewhere")
41                                                    .setPostalCode("94025")
42                                                    .build();
43        verifier.verify(addr, problems);
44        assertTrue(problems.toString(), problems.isEmpty());  // no mismatch
45    }
46
47    public void testUnitedStatesZipMismatch() {
48        AddressData addr = new AddressData.Builder().setCountry("US")
49                                                    .setAdminArea("CA")
50                                                    .setLocality("Mountain View")
51                                                    .setPostalCode("12345")
52                                                    .build();
53        verifier.verify(addr, problems);
54
55        assertEquals(AddressProblemType.MISMATCHING_VALUE,
56                     problems.getProblem(AddressField.POSTAL_CODE));
57    }
58
59    public void testUnitedStatesNotOk() {
60        AddressData addr = new AddressData.Builder().setCountry("US")
61                                                    .setAdminArea("CA")
62                                                    .setLocality(null)
63                                                    .setDependentLocality("Foo Bar")
64                                                    .setPostalCode("12345")
65                                                    .build();
66        verifier.verify(addr, problems);
67
68        assertEquals(AddressProblemType.MISMATCHING_VALUE,
69                     problems.getProblem(AddressField.POSTAL_CODE));
70        assertEquals(AddressProblemType.MISSING_REQUIRED_FIELD,
71                     problems.getProblem(AddressField.LOCALITY));
72    }
73
74    public void testChinaOk() {
75        AddressData addr = new AddressData.Builder().setCountry("CN")
76                                                    .setAdminArea("Beijing Shi")
77                                                    .setLocality("Xicheng Qu")
78                                                    .setAddress("Yitiao Lu")
79                                                    .setPostalCode("123456")
80                                                    .build();
81        verifier.verify(addr, problems);
82        assertTrue(problems.toString(), problems.isEmpty());
83    }
84
85    public void testGermanAddress() {
86        AddressData addr = new AddressData.Builder().setCountry("DE")
87                                                    .setLocality("Berlin")
88                                                    .setAddress("Huttenstr. 50")
89                                                    .setPostalCode("10553")
90                                                    .setOrganization("BMW AG Niederkassung Berlin")
91                                                    .setRecipient("Herr Diefendorf")
92                                                    .build();
93
94        verifier.verify(addr, problems);
95        assertTrue(problems.toString(), problems.isEmpty());
96
97        // Clones address but leave city empty.
98        addr = new AddressData.Builder().set(addr).setLocality(null).build();
99
100        verifier.verify(addr, problems);
101        assertEquals(AddressProblemType.MISSING_REQUIRED_FIELD,
102                     problems.getProblem(AddressField.LOCALITY));
103    }
104
105    public void testIrishAddress() {
106        AddressData addr = new AddressData.Builder().setCountry("IE")
107                                                    .setLocality("Dublin")
108                                                    .setAdminArea("Co. Dublin")
109                                                    .setAddress("7424 118 Avenue NW")
110                                                    .setRecipient("Conan O'Brien")
111                                                    .build();
112
113        verifier.verify(addr, problems);
114        assertTrue(problems.toString(), problems.isEmpty());
115
116        // Clones address but leave county empty. This address should be valid
117        // since county is not required.
118        addr = new AddressData.Builder().set(addr).setAdminArea(null).build();
119
120        verifier.verify(addr, problems);
121        assertTrue(problems.toString(), problems.isEmpty());
122    }
123
124    public void testChinaPostalCodeBadFormat() {
125        AddressData addr = new AddressData.Builder().setCountry("CN")
126                                                    .setAdminArea("Beijing Shi")
127                                                    .setLocality("Xicheng Qu")
128                                                    .setPostalCode("12345")
129                                                    .build();
130        verifier.verify(addr, problems);
131
132        // ensure problem is unrecognized format and problem is in POSTAL_CODE
133        assertEquals(AddressProblemType.UNRECOGNIZED_FORMAT,
134                     problems.getProblem(AddressField.POSTAL_CODE));
135    }
136
137    /**
138     * If there is a postal code pattern for a certain country, and the input postal code is empty,
139     * it should not be reported as bad postal code format. Whether empty postal code is ok should
140     * be determined by checks for required fields.
141     */
142    public void testEmptyPostalCodeReportedAsGoodFormat() {
143        // Chilean address has a postal code format pattern, but does not require
144        // postal code. The following address is valid.
145        AddressData addr = new AddressData.Builder().setCountry("CL")
146                                                    .setAddressLine1("GUSTAVO LE PAIGE ST #159")
147                                                    .setAdminArea("Atacama")
148                                                    .setLocality("San Pedro")
149                                                    .setPostalCode("")
150                                                    .build();
151        verifier.verify(addr, problems);
152        assertTrue(problems.toString(), problems.isEmpty());
153
154        problems.clear();
155
156        // Now checks for US addresses, which requires postal code. The following
157        // address's postal code is wrong because it misses required field, not
158        // because it mismatches expected postal code pattern.
159        addr = new AddressData.Builder().setCountry("US").setPostalCode("").build();
160        problems.clear();
161        verifier.verify(addr, problems);
162
163        assertEquals(AddressProblemType.MISSING_REQUIRED_FIELD,
164                     problems.getProblem(AddressField.POSTAL_CODE));
165    }
166
167    public void testChinaTaiwanOk() {
168        AddressData addr = new AddressData.Builder().setCountry("CN")
169                                                    .setAdminArea("Taiwan")
170                                                    .setLocality("Taichung City")
171                                                    .setDependentLocality("Situn District")
172                                                    .setAddress("12345 Yitiao Lu")
173                                                    .setPostalCode("407")
174                                                    .build();
175        verifier.verify(addr, problems);
176        assertTrue(problems.toString(), problems.isEmpty());
177    }
178
179    public void testChinaTaiwanUnknownDistrict() {
180        AddressData addr = new AddressData.Builder().setCountry("CN")
181                                                    .setAdminArea("Taiwan")
182                                                    .setLocality("Taichung City")
183                                                    .setDependentLocality("Foo Bar")
184                                                    .setPostalCode("400")
185                                                    .build();
186        verifier.verify(addr, problems);
187
188        assertEquals(AddressProblemType.UNKNOWN_VALUE,
189                     problems.getProblem(AddressField.DEPENDENT_LOCALITY));
190    }
191
192    public void testStreetVerification() {
193        // missing street address
194        AddressData addr = new AddressData.Builder().setCountry("US")
195                                                    .setAdminArea("CA")
196                                                    .setLocality("Mountain View")
197                                                    .setPostalCode("94025")
198                                                    .build();
199
200        assertNull(addr.getAddressLine1());
201        assertNull(addr.getAddressLine2());
202
203        verifier.verify(addr, problems);
204
205        assertEquals(AddressProblemType.MISSING_REQUIRED_FIELD,
206                     problems.getProblem(AddressField.STREET_ADDRESS));
207    }
208
209    // Tests The Bahamas' address
210    public void failingtestBahamas() {
211        final AddressData address =
212                new AddressData.Builder().setAddress("Abaco Beach Resort & Boat Habour")
213                                         .setLocality("Treasure Cay")
214                                         .setAdminArea("Abaco")
215                                         .setCountry("BS")
216                                         .build();
217        verifier.verify(address, problems);
218        assertTrue(problems.toString(), problems.isEmpty());
219    }
220
221    public void testJapan() {
222        // added AdminArea since address verification can't infer it from Kyoto City
223        // commented out dependent locality since address verification doesn't use it
224        // TODO: support inference of higher levels from lower ones
225        // TODO: add dependent locality support for japan addresses
226        final AddressData address =
227                new AddressData.Builder()
228                        .setRecipient("\u5BAE\u672C \u8302")  // SHIGERU_MIYAMOTO
229                        .setAddress("\u4E0A\u9CE5\u7FBD\u927E\u7ACB\u753A11\u756A\u5730")
230                        .setAdminArea("\u4eac\u90fd\u5e9c")  // Kyoto prefecture, added
231                        .setLocality("\u4EAC\u90FD\u5E02")  // Kyoto city
232                        // .setDependentLocality("\u5357\u533A")
233                        .setCountry("JP")
234                        .setPostalCode("601-8501")
235                        .build();
236        verifier.verify(address, problems);
237        assertTrue(problems.toString(), problems.isEmpty());
238    }
239
240    public void testJapanLatin() {
241        // added AdminArea since address verification can't infer it from Kyoto City
242        // commented out dependent locality since address verification doesn't use it
243        final AddressData address =
244                new AddressData.Builder()
245                        .setRecipient("Shigeru Miyamoto")  // SHIGERU_MIYAMOTO_ENGLISH
246                        .setAddress("11-1 Kamitoba-hokotate-cho")
247                        .setAdminArea("KYOTO")  // Kyoto prefecture, added
248                        .setLocality("Kyoto")  // Kyoto city
249                        // .setDependentLocality("Minami-ku")
250                        .setLanguageCode("ja_Latn")
251                        .setCountry("JP")
252                        .setPostalCode("601-8501")
253                        .build();
254        verifier.verify(address, problems);
255        assertTrue(problems.toString(), problems.isEmpty());
256    }
257}
258