• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2009 The Android Open Source Project
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 package android.telephony.cts;
17 
18 import static androidx.test.InstrumentationRegistry.getContext;
19 
20 import static org.junit.Assert.assertEquals;
21 import static org.junit.Assert.assertFalse;
22 import static org.junit.Assert.assertNull;
23 import static org.junit.Assert.assertTrue;
24 import static org.junit.Assume.assumeTrue;
25 
26 import android.content.ContentResolver;
27 import android.content.ContentValues;
28 import android.content.Context;
29 import android.content.Intent;
30 import android.content.pm.PackageManager;
31 import android.net.Uri;
32 import android.os.RemoteException;
33 import android.platform.test.annotations.AppModeNonSdkSandbox;
34 import android.platform.test.flag.junit.CheckFlagsRule;
35 import android.platform.test.flag.junit.DeviceFlagsValueProvider;
36 import android.provider.Contacts.People;
37 import android.telephony.PhoneNumberUtils;
38 import android.telephony.SubscriptionManager;
39 import android.telephony.TelephonyManager;
40 import android.text.Editable;
41 import android.text.Spannable;
42 import android.text.SpannableString;
43 import android.text.SpannableStringBuilder;
44 import android.text.style.TtsSpan;
45 
46 import org.junit.After;
47 import org.junit.Before;
48 import org.junit.Rule;
49 import org.junit.Test;
50 
51 import java.util.Locale;
52 
53 public class PhoneNumberUtilsTest {
54     @Rule
55     public final CheckFlagsRule mCheckFlagsRule =
56             DeviceFlagsValueProvider.createCheckFlagsRule();
57 
58     private static final int MIN_MATCH = 7;
59 
60     // mPhoneNumber ~ "+17005550020", length == 7.
61     private byte[] mPhoneNumber = { (byte) 0x91, (byte) 0x71, (byte) 0x00, (byte) 0x55,
62             (byte) 0x05, (byte) 0x20, (byte) 0xF0 };
63 
64     private int mOldMinMatch;
65 
66     private PackageManager mPackageManager;
67     @Before
setUp()68     public void setUp() throws Exception {
69         mOldMinMatch = PhoneNumberUtils.getMinMatchForTest();
70         PhoneNumberUtils.setMinMatchForTest(MIN_MATCH);
71 
72         mPackageManager = getContext().getPackageManager();
73         assumeTrue(
74                 "Skipping test that requires FEATURE_TELEPHONY_CALLING",
75                 mPackageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY_CALLING));
76     }
77 
78     @After
tearDown()79     public void tearDown() throws Exception {
80         PhoneNumberUtils.setMinMatchForTest(mOldMinMatch);
81     }
82 
83     @Test
testExtractMethods()84     public void testExtractMethods() {
85 
86         // Test extractNetworkPortion
87         assertNull(PhoneNumberUtils.extractNetworkPortion(null));
88         assertEquals("+17005554141", PhoneNumberUtils.extractNetworkPortion("+17005554141"));
89         assertEquals("+17005554141*#N",
90                 PhoneNumberUtils.extractNetworkPortion("+1 (700).555-4141*#N"));
91         assertEquals("170055541", PhoneNumberUtils.extractNetworkPortion(
92                 String.format("1 (700).555-41%c1234", PhoneNumberUtils.PAUSE)));
93         assertEquals("**21**17005554141#",
94                 PhoneNumberUtils.extractNetworkPortion("**21**+17005554141#"));
95 
96         // Test extractPostDialPortion
97         assertNull(PhoneNumberUtils.extractPostDialPortion(null));
98         assertEquals("", PhoneNumberUtils.extractPostDialPortion("+17005554141"));
99         assertEquals(String.format("%c1234", PhoneNumberUtils.PAUSE),
100                 PhoneNumberUtils.extractPostDialPortion(
101                 String.format("+1 (700).555-41NN%c1234", PhoneNumberUtils.PAUSE)));
102         assertEquals(String.format("%c1234", PhoneNumberUtils.WAIT),
103                 PhoneNumberUtils.extractPostDialPortion(
104                 String.format("+1 (700).555-41NN%c1234", PhoneNumberUtils.WAIT)));
105         assertEquals(String.format("%c1234%c%cN", PhoneNumberUtils.WAIT, PhoneNumberUtils.PAUSE,
106                 PhoneNumberUtils.WAIT), PhoneNumberUtils
107                 .extractPostDialPortion(
108                         String.format("+1 (700).555-41NN%c1-2.34 %c%cN", PhoneNumberUtils.WAIT,
109                                 PhoneNumberUtils.PAUSE,
110                                 PhoneNumberUtils.WAIT)));
111         assertEquals("example", PhoneNumberUtils.getUsernameFromUriNumber("example@example.com"));
112     }
113 
114     @Test
testCallMethods()115     public void testCallMethods() {
116         // Test calledPartyBCDToString
117         assertEquals("+17005550020", PhoneNumberUtils.calledPartyBCDToString(mPhoneNumber, 0, 7));
118 
119         // Test toCallerIDMinMatch
120         assertNull(PhoneNumberUtils.toCallerIDMinMatch(null));
121 //        assertEquals("1414555", PhoneNumberUtils.toCallerIDMinMatch("17005554141"));
122 //        assertEquals("1414555", PhoneNumberUtils.toCallerIDMinMatch("1-700-555-4141"));
123 //        assertEquals("1414555", PhoneNumberUtils.toCallerIDMinMatch("1-700-555-4141,1234"));
124 //        assertEquals("1414555", PhoneNumberUtils.toCallerIDMinMatch("1-700-555-4141;1234"));
125 //        assertEquals("NN14555", PhoneNumberUtils.toCallerIDMinMatch("1-700-555-41NN"));
126         assertEquals("", PhoneNumberUtils.toCallerIDMinMatch(""));
127         assertEquals("0032", PhoneNumberUtils.toCallerIDMinMatch("2300"));
128         assertEquals("0032+", PhoneNumberUtils.toCallerIDMinMatch("+2300"));
129         assertEquals("#130#*", PhoneNumberUtils.toCallerIDMinMatch("*#031#"));
130 
131         // Test networkPortionToCalledPartyBCD, calledPartyBCDToString
132         byte[] bRet = PhoneNumberUtils.networkPortionToCalledPartyBCD("+17005550020");
133         assertEquals(mPhoneNumber.length, bRet.length);
134         for (int i = 0; i < mPhoneNumber.length; i++) {
135             assertEquals(mPhoneNumber[i], bRet[i]);
136         }
137         bRet = PhoneNumberUtils.networkPortionToCalledPartyBCD("7005550020");
138         assertEquals("7005550020", PhoneNumberUtils.calledPartyBCDToString(bRet, 0, bRet.length));
139 
140         // Test calledPartyBCDFragmentToString
141         assertEquals("1917005550020", PhoneNumberUtils.calledPartyBCDFragmentToString(mPhoneNumber,
142                 0, 7));
143 
144         // Test networkPortionToCalledPartyBCDWithLength
145         bRet = PhoneNumberUtils.networkPortionToCalledPartyBCDWithLength("+17005550020");
146         assertEquals(mPhoneNumber.length + 1, bRet.length);
147         for (int i = 0; i < mPhoneNumber.length; i++) {
148             assertEquals(mPhoneNumber[i], bRet[i + 1]);
149         }
150 
151         // Test numberToCalledPartyBCD
152         bRet = PhoneNumberUtils.numberToCalledPartyBCD("+17005550020");
153         assertEquals(mPhoneNumber.length, bRet.length);
154         for (int i = 0; i < mPhoneNumber.length; i++) {
155             assertEquals(mPhoneNumber[i], bRet[i]);
156         }
157     }
158 
159     @Test
160     @AppModeNonSdkSandbox(reason = "SDK sandboxes do not have access to contacts provider")
testGetMethods()161     public void testGetMethods() throws RemoteException {
162         // Test getStrippedReversed
163         assertNull(PhoneNumberUtils.getStrippedReversed(null));
164         assertEquals("14145550071", PhoneNumberUtils.getStrippedReversed("1-700-555-4141"));
165         assertEquals("14145550071", PhoneNumberUtils.getStrippedReversed("1-700-555-4141,1234"));
166         assertEquals("14145550071", PhoneNumberUtils.getStrippedReversed("1-700-555-4141;1234"));
167         assertEquals("NN145550071", PhoneNumberUtils.getStrippedReversed("1-700-555-41NN"));
168         assertEquals("", PhoneNumberUtils.getStrippedReversed(""));
169         assertEquals("#130#*+", PhoneNumberUtils.getStrippedReversed("+*#031#"));
170 
171         // Test getFormatTypeForLocale
172         int formatType = PhoneNumberUtils.getFormatTypeForLocale(Locale.CHINA);
173         assertEquals(PhoneNumberUtils.FORMAT_UNKNOWN, formatType);
174         formatType = PhoneNumberUtils.getFormatTypeForLocale(Locale.US);
175         assertEquals(PhoneNumberUtils.FORMAT_NANP, formatType);
176         formatType = PhoneNumberUtils.getFormatTypeForLocale(Locale.JAPAN);
177         assertEquals(PhoneNumberUtils.FORMAT_JAPAN, formatType);
178 
179         // Test getNumberFromIntent, query nothing, return null.
180         Intent intent = new Intent();
181         Context context = getContext();
182         assertNull(PhoneNumberUtils.getNumberFromIntent(intent, context));
183 
184         intent = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:+18005555555"));
185         assertEquals("+18005555555", PhoneNumberUtils.getNumberFromIntent(intent, getContext()));
186 
187         ContentResolver cr = getContext().getContentResolver();
188         Uri personRecord = null;
189         Uri phoneRecord = null;
190         try {
191             // insert a contact with phone number
192             ContentValues values = new ContentValues();
193             values.put(People.NAME, "CTS test contact");
194             personRecord = cr.insert(People.CONTENT_URI, values);
195             Uri phoneUri = Uri.withAppendedPath(personRecord, People.Phones.CONTENT_DIRECTORY);
196             values.clear();
197             values.put(People.Phones.TYPE, People.Phones.TYPE_HOME);
198             values.put(People.Phones.NUMBER, "+18005552871");
199             phoneRecord = cr.insert(phoneUri, values);
200 
201             intent = new Intent(Intent.ACTION_DIAL, phoneRecord);
202             assertEquals("+18005552871",
203                     PhoneNumberUtils.getNumberFromIntent(intent, getContext()));
204         } finally {
205             if (personRecord != null) {
206                 cr.delete(personRecord, null, null);
207             }
208             if (phoneRecord != null) {
209                 cr.delete(phoneRecord, null, null);
210             }
211         }
212     }
213 
214     @Test
testFormatMethods()215     public void testFormatMethods() {
216         // Test formatNanpNumber
217         SpannableStringBuilder builderNumber = new SpannableStringBuilder();
218         builderNumber.append("8005551212");
219         PhoneNumberUtils.formatNanpNumber(builderNumber);
220         assertEquals("800-555-1212", builderNumber.toString());
221         builderNumber.clear();
222         builderNumber.append("800555121");
223         PhoneNumberUtils.formatNanpNumber(builderNumber);
224         assertEquals("800-555-121", builderNumber.toString());
225         builderNumber.clear();
226         builderNumber.append("555-1212");
227         PhoneNumberUtils.formatNanpNumber(builderNumber);
228         assertEquals("555-1212", builderNumber.toString());
229         builderNumber.clear();
230         builderNumber.append("180055512");
231         PhoneNumberUtils.formatNanpNumber(builderNumber);
232         assertEquals("1-800-555-12", builderNumber.toString());
233         builderNumber.clear();
234         builderNumber.append("+180055512");
235         PhoneNumberUtils.formatNanpNumber(builderNumber);
236         assertEquals("+1-800-555-12", builderNumber.toString());
237 
238         // Test convertKeypadLettersToDigits
239         assertEquals("1-800-4664-411", PhoneNumberUtils
240                 .convertKeypadLettersToDigits("1-800-GOOG-411"));
241         assertEquals("1-800-466-4411", PhoneNumberUtils
242                 .convertKeypadLettersToDigits("1-800-466-4411"));
243         assertEquals("222-333-444-555-666-7777-888-9999", PhoneNumberUtils
244                 .convertKeypadLettersToDigits("ABC-DEF-GHI-JKL-MNO-PQRS-TUV-WXYZ"));
245         assertEquals("222-333-444-555-666-7777-888-9999", PhoneNumberUtils
246                 .convertKeypadLettersToDigits("abc-def-ghi-jkl-mno-pqrs-tuv-wxyz"));
247         assertEquals("(800) 222-3334", PhoneNumberUtils
248                 .convertKeypadLettersToDigits("(800) ABC-DEFG"));
249 
250         // Test stringFromStringAndTOA
251         assertNull(PhoneNumberUtils.stringFromStringAndTOA(null, 1));
252         assertEquals("+888888888", PhoneNumberUtils.stringFromStringAndTOA("888888888",
253                 PhoneNumberUtils.TOA_International));
254 
255         // Test formatJapaneseNumber
256         Editable jpEditNumber = Editable.Factory.getInstance().newEditable("0377777777");
257         PhoneNumberUtils.formatJapaneseNumber(jpEditNumber);
258         assertEquals("03-7777-7777", jpEditNumber.toString());
259         jpEditNumber = Editable.Factory.getInstance().newEditable("09077777777");
260         PhoneNumberUtils.formatJapaneseNumber(jpEditNumber);
261         assertEquals("090-7777-7777", jpEditNumber.toString());
262         jpEditNumber = Editable.Factory.getInstance().newEditable("0120777777");
263         PhoneNumberUtils.formatJapaneseNumber(jpEditNumber);
264         assertEquals("0120-777-777", jpEditNumber.toString());
265         jpEditNumber = Editable.Factory.getInstance().newEditable("+81377777777");
266         PhoneNumberUtils.formatJapaneseNumber(jpEditNumber);
267         assertEquals("+81-3-7777-7777", jpEditNumber.toString());
268         jpEditNumber = Editable.Factory.getInstance().newEditable("+819077777777");
269         PhoneNumberUtils.formatJapaneseNumber(jpEditNumber);
270         assertEquals("+81-90-7777-7777", jpEditNumber.toString());
271 
272         // Test formatNumber(String). Only numbers begin with +1 or +81 can be formatted.
273         assertEquals("+1-888-888-888", PhoneNumberUtils.formatNumber("+1888888888"));
274         // Test formatNumber(Editable, int)
275         Editable editNumber = Editable.Factory.getInstance().newEditable("0377777777");
276         PhoneNumberUtils.formatNumber(editNumber, PhoneNumberUtils.FORMAT_UNKNOWN);
277         assertEquals("0377777777", editNumber.toString());
278         editNumber = Editable.Factory.getInstance().newEditable("+177777777");
279         PhoneNumberUtils.formatNumber(editNumber, PhoneNumberUtils.FORMAT_UNKNOWN);
280         assertEquals("+1-777-777-77", editNumber.toString());
281         editNumber = Editable.Factory.getInstance().newEditable("+8177777777");
282         PhoneNumberUtils.formatNumber(editNumber, PhoneNumberUtils.FORMAT_UNKNOWN);
283         assertEquals("+81-77-777-777", editNumber.toString());
284 
285         // Test stripSeparators
286         assertEquals("+188888888", PhoneNumberUtils.stripSeparators("+188-888-888"));
287 
288         // Test toaFromString
289         assertEquals(PhoneNumberUtils.TOA_International, PhoneNumberUtils
290                 .toaFromString("+88888888"));
291         assertEquals(PhoneNumberUtils.TOA_Unknown, PhoneNumberUtils.toaFromString("88888888"));
292     }
293 
294     @Test
testJudgeMethods()295     public void testJudgeMethods() {
296         // Test is12Key, isDialable, isISODigit, isReallyDialable, isStartsPostDial
297         for (char c = '0'; c <= '9'; c++) {
298             assertTrue(PhoneNumberUtils.is12Key(c));
299             assertTrue(PhoneNumberUtils.isDialable(c));
300             assertTrue(PhoneNumberUtils.isISODigit(c));
301             assertTrue(PhoneNumberUtils.isNonSeparator(c));
302             assertTrue(PhoneNumberUtils.isReallyDialable(c));
303         }
304         char c = '*';
305         assertTrue(PhoneNumberUtils.is12Key(c));
306         assertTrue(PhoneNumberUtils.isDialable(c));
307         assertTrue(PhoneNumberUtils.isNonSeparator(c));
308         assertTrue(PhoneNumberUtils.isReallyDialable(c));
309         c = '#';
310         assertTrue(PhoneNumberUtils.is12Key(c));
311         assertTrue(PhoneNumberUtils.isDialable(c));
312         assertTrue(PhoneNumberUtils.isNonSeparator(c));
313         assertTrue(PhoneNumberUtils.isReallyDialable(c));
314         c = '$';
315         assertFalse(PhoneNumberUtils.is12Key(c));
316         assertFalse(PhoneNumberUtils.isDialable(c));
317         assertFalse(PhoneNumberUtils.isDialable(c));
318         c = '+';
319         assertTrue(PhoneNumberUtils.isDialable(c));
320         assertFalse(PhoneNumberUtils.isISODigit(c));
321         assertTrue(PhoneNumberUtils.isNonSeparator(c));
322         assertTrue(PhoneNumberUtils.isReallyDialable(c));
323         c = PhoneNumberUtils.WILD;
324         assertTrue(PhoneNumberUtils.isDialable(c));
325         assertTrue(PhoneNumberUtils.isNonSeparator(c));
326         assertFalse(PhoneNumberUtils.isReallyDialable(c));
327         c = PhoneNumberUtils.WAIT;
328         assertTrue(PhoneNumberUtils.isNonSeparator(c));
329         assertTrue(PhoneNumberUtils.isStartsPostDial(c));
330         c = PhoneNumberUtils.PAUSE;
331         assertTrue(PhoneNumberUtils.isNonSeparator(c));
332         assertTrue(PhoneNumberUtils.isStartsPostDial(c));
333         c = '8';
334         assertFalse(PhoneNumberUtils.isStartsPostDial(c));
335 
336         // Test isEmergencyNumber, now only know US emergency number
337         TelephonyManager tm = (TelephonyManager)getContext().getSystemService(
338                  Context.TELEPHONY_SERVICE);
339         // Test isEmergencyNumber, now only know US emergency number
340         if ("US".equals(tm.getSimCountryIso())) {
341             assertTrue(PhoneNumberUtils.isEmergencyNumber("911"));
342             assertFalse(PhoneNumberUtils.isEmergencyNumber("119"));
343         }
344 
345         // Test isGlobalPhoneNumber
346         assertTrue(PhoneNumberUtils.isGlobalPhoneNumber("+17005554141"));
347         assertFalse(PhoneNumberUtils.isGlobalPhoneNumber("android"));
348 
349         // Test isWellFormedSmsAddress
350         assertTrue(PhoneNumberUtils.isWellFormedSmsAddress("+17005554141"));
351         assertFalse(PhoneNumberUtils.isWellFormedSmsAddress("android"));
352 
353         // Test isUriNumber
354         assertTrue(PhoneNumberUtils.isUriNumber("example@example.com"));
355         assertFalse(PhoneNumberUtils.isUriNumber("+18005555555"));
356 
357         // Test isVoicemailNumber -- this is closely tied to the SIM so we'll just test some basic
358         // cases
359         assertFalse(PhoneNumberUtils.isVoiceMailNumber(getContext(),
360                 SubscriptionManager.getDefaultSubscriptionId(), null));
361         assertFalse(PhoneNumberUtils.isVoiceMailNumber(getContext(),
362                 SubscriptionManager.getDefaultSubscriptionId(), ""));
363 
364         // Test isWpsCallNumber
365         // Test number without special symbols.
366         assertFalse(PhoneNumberUtils.isWpsCallNumber("12345678"));
367 
368         // TTS number should not be recognized as wps.
369         assertFalse(PhoneNumberUtils.isWpsCallNumber("*23212345678"));
370         assertFalse(PhoneNumberUtils.isWpsCallNumber("*232#12345678"));
371 
372         // Check WPS valid numbers
373         assertTrue(PhoneNumberUtils.isWpsCallNumber("*27212345678"));
374         assertTrue(PhoneNumberUtils.isWpsCallNumber("*31#*27212345678"));
375         assertTrue(PhoneNumberUtils.isWpsCallNumber("#31#*27212345678"));
376     }
377 
378     @Test
testGetPhoneTtsSpan()379     public void testGetPhoneTtsSpan() {
380         // Setup: phone number without a country code. Lets keep coverage minimal to avoid
381         // exercising the underlying PhoneNumberUtil or constraining localization changes.
382         String phoneNumber = "6512223333";
383         // Execute
384         TtsSpan ttsSpan = PhoneNumberUtils.createTtsSpan(phoneNumber);
385         // Verify: the created TtsSpan contains the phone number.
386         assertEquals("6512223333", ttsSpan.getArgs().get(TtsSpan.ARG_NUMBER_PARTS));
387     }
388 
389     @Test
testAddPhoneTtsSpan()390     public void testAddPhoneTtsSpan() {
391         // Setup: phone number without a country code. Lets keep coverage minimal to avoid
392         // exercising the underlying PhoneNumberUtil or constraining localization changes.
393         Spannable spannable = new SpannableString("Hello 6502223333");
394         // Execute
395         PhoneNumberUtils.addTtsSpan(spannable, 5, spannable.length());
396         // Verify: the Spannable is annotated with a TtsSpan in the correct location.
397         TtsSpan[] ttsSpans = spannable.getSpans(5, spannable.length() - 1, TtsSpan.class);
398         assertEquals(1, ttsSpans.length);
399         assertEquals("6502223333", ttsSpans[0].getArgs().get(TtsSpan.ARG_NUMBER_PARTS));
400     }
401 
402     @Test
testGetPhoneTtsSpannable()403     public void testGetPhoneTtsSpannable() {
404         // Setup: phone number without a country code. Lets keep coverage minimal to avoid
405         // exercising the underlying PhoneNumberUtil or constraining localization changes.
406         CharSequence phoneNumber = "6512223333";
407         // Execute
408         Spannable spannable = (Spannable) PhoneNumberUtils.createTtsSpannable(phoneNumber);
409         // Verify: returned char sequence contains a TtsSpan with the phone number in it
410         TtsSpan[] ttsSpans = spannable.getSpans(0, spannable.length() - 1, TtsSpan.class);
411         assertEquals(1, ttsSpans.length);
412         assertEquals("6512223333", ttsSpans[0].getArgs().get(TtsSpan.ARG_NUMBER_PARTS));
413     }
414 
415     @Test
testFormatNumberToE164()416     public void testFormatNumberToE164() {
417         assertNull(PhoneNumberUtils.formatNumber("invalid#", "US"));
418         assertNull(PhoneNumberUtils.formatNumberToE164("1234567", "US"));
419 
420         assertEquals("+18004664114", PhoneNumberUtils.formatNumberToE164("800-GOOG-114", "US"));
421         assertEquals("+16502910000", PhoneNumberUtils.formatNumberToE164("650 2910000", "US"));
422         assertEquals("+12023458246", PhoneNumberUtils.formatNumberToE164("(202)345-8246", "US"));
423         assertEquals("+812023458246", PhoneNumberUtils.formatNumberToE164("202-345-8246", "JP"));
424     }
425 
426     @Test
testFormatNumberToE164_countryCodeLowerCase()427     public void testFormatNumberToE164_countryCodeLowerCase() {
428         assertNull(PhoneNumberUtils.formatNumber("invalid#", "us"));
429         assertNull(PhoneNumberUtils.formatNumberToE164("1234567", "us"));
430 
431         assertEquals("+18004664114", PhoneNumberUtils.formatNumberToE164("800-GOOG-114", "us"));
432         assertEquals("+16502910000", PhoneNumberUtils.formatNumberToE164("650 2910000", "us"));
433         assertEquals("+12023458246", PhoneNumberUtils.formatNumberToE164("(202)345-8246", "us"));
434         assertEquals("+812023458246", PhoneNumberUtils.formatNumberToE164("202-345-8246", "jp"));
435     }
436 
437     @Test
testAreSamePhoneNumber()438     public void testAreSamePhoneNumber() {
439         assertFalse(PhoneNumberUtils.areSamePhoneNumber("abcd", "bcde", "us"));
440         assertTrue(PhoneNumberUtils.areSamePhoneNumber("1-800-flowers", "800-flowers", "us"));
441         assertFalse(PhoneNumberUtils.areSamePhoneNumber("1-800-flowers", "1-800-abcdefg", "us"));
442 
443         assertTrue(PhoneNumberUtils.areSamePhoneNumber("999", "999", "us"));
444         assertFalse(PhoneNumberUtils.areSamePhoneNumber("123456789", "923456789", "us"));
445         assertTrue(PhoneNumberUtils.areSamePhoneNumber("123456789", "0123456789", "us"));
446         assertTrue(PhoneNumberUtils.areSamePhoneNumber("650-253-0000", "650 253 0000", "us"));
447         assertTrue(PhoneNumberUtils.areSamePhoneNumber("650-253-0000", "1-650-253-0000", "us"));
448 
449         //TODO: Change the expected result to false after libphonenumber improvement
450         assertTrue(PhoneNumberUtils.areSamePhoneNumber("650-253-0000", "11-650-253-0000", "us"));
451 
452         assertTrue(PhoneNumberUtils.areSamePhoneNumber("650-253-0000", "0-650-253-0000", "us"));
453         assertFalse(PhoneNumberUtils.areSamePhoneNumber("555-4141", "+1-700-555-4141", "us"));
454         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+1650-253-0000", "6502530000", "us"));
455         assertFalse(PhoneNumberUtils.areSamePhoneNumber("001650-253-0000", "6502530000", "us"));
456         assertTrue(PhoneNumberUtils.areSamePhoneNumber("0111650-253-0000", "6502530000", "us"));
457         assertFalse(PhoneNumberUtils.areSamePhoneNumber("+19012345678", "+819012345678", "us"));
458         assertTrue(PhoneNumberUtils.areSamePhoneNumber("008001231234", "8001231234", "us"));
459         assertFalse(PhoneNumberUtils.areSamePhoneNumber("+66811234567", "166811234567", "us"));
460         assertFalse(PhoneNumberUtils.areSamePhoneNumber("080-1234-5678", "+819012345678", "us"));
461 
462         //TODO: Change the expected result to false after libphonenumber improvement
463         assertTrue(PhoneNumberUtils.areSamePhoneNumber("011 11 7005554141", "+17005554141", "us"));
464         assertFalse(PhoneNumberUtils.areSamePhoneNumber("+44 207 792 3490", "00 207 792 3490",
465                 "us"));
466         assertTrue(PhoneNumberUtils.areSamePhoneNumber("16610001234", "6610001234", "us"));
467         assertFalse(PhoneNumberUtils.areSamePhoneNumber("550-450-3605", "+14504503605", "us"));
468         assertFalse(PhoneNumberUtils.areSamePhoneNumber("550-450-3605", "+15404503605", "us"));
469         assertFalse(PhoneNumberUtils.areSamePhoneNumber("550-450-3605", "+15514503605", "us"));
470 
471         assertFalse(PhoneNumberUtils.areSamePhoneNumber("+31771234567", "0771234567", "jp"));
472         assertTrue(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "+819012345678", "jp"));
473         assertTrue(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "90-1234-5678", "jp"));
474         assertFalse(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "080-1234-5678", "jp"));
475         assertFalse(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "190-1234-5678", "jp"));
476         assertFalse(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "890-1234-5678", "jp"));
477         assertFalse(PhoneNumberUtils.areSamePhoneNumber("080-1234-5678", "+819012345678", "jp"));
478         assertFalse(PhoneNumberUtils.areSamePhoneNumber("290-1234-5678", "+819012345678", "jp"));
479 
480         //TODO: Change the expected result to false after libphonenumber improvement
481         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+79161234567", "89161234567", "ru"));
482 
483         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+33123456789", "0123456789", "fr"));
484 
485         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+31771234567", "0771234567", "nl"));
486 
487         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+593(800)123-1234", "8001231234", "ec"));
488     }
489 
490     @Test
testAreSamePhoneNumber_countryCodeUpperCase()491     public void testAreSamePhoneNumber_countryCodeUpperCase() {
492         assertFalse(PhoneNumberUtils.areSamePhoneNumber("abcd", "bcde", "US"));
493         assertTrue(PhoneNumberUtils.areSamePhoneNumber("1-800-flowers", "800-flowers", "US"));
494         assertFalse(PhoneNumberUtils.areSamePhoneNumber("1-800-flowers", "1-800-abcdefg", "US"));
495 
496         assertTrue(PhoneNumberUtils.areSamePhoneNumber("999", "999", "US"));
497         assertFalse(PhoneNumberUtils.areSamePhoneNumber("123456789", "923456789", "US"));
498         assertTrue(PhoneNumberUtils.areSamePhoneNumber("123456789", "0123456789", "US"));
499         assertTrue(PhoneNumberUtils.areSamePhoneNumber("650-253-0000", "650 253 0000", "US"));
500         assertTrue(PhoneNumberUtils.areSamePhoneNumber("650-253-0000", "1-650-253-0000", "US"));
501 
502         //TODO: Change the expected result to false after libphonenumber improvement
503         assertTrue(PhoneNumberUtils.areSamePhoneNumber("650-253-0000", "11-650-253-0000", "US"));
504 
505         assertTrue(PhoneNumberUtils.areSamePhoneNumber("650-253-0000", "0-650-253-0000", "US"));
506         assertFalse(PhoneNumberUtils.areSamePhoneNumber("555-4141", "+1-700-555-4141", "US"));
507         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+1650-253-0000", "6502530000", "US"));
508         assertFalse(PhoneNumberUtils.areSamePhoneNumber("001650-253-0000", "6502530000", "US"));
509         assertTrue(PhoneNumberUtils.areSamePhoneNumber("0111650-253-0000", "6502530000", "US"));
510         assertFalse(PhoneNumberUtils.areSamePhoneNumber("+19012345678", "+819012345678", "US"));
511         assertTrue(PhoneNumberUtils.areSamePhoneNumber("008001231234", "8001231234", "US"));
512         assertFalse(PhoneNumberUtils.areSamePhoneNumber("+66811234567", "166811234567", "US"));
513         assertFalse(PhoneNumberUtils.areSamePhoneNumber("080-1234-5678", "+819012345678", "US"));
514 
515         //TODO: Change the expected result to false after libphonenumber improvement
516         assertTrue(PhoneNumberUtils.areSamePhoneNumber("011 11 7005554141", "+17005554141", "US"));
517         assertFalse(PhoneNumberUtils.areSamePhoneNumber("+44 207 792 3490", "00 207 792 3490",
518                 "US"));
519         assertTrue(PhoneNumberUtils.areSamePhoneNumber("16610001234", "6610001234", "US"));
520         assertFalse(PhoneNumberUtils.areSamePhoneNumber("550-450-3605", "+14504503605", "US"));
521         assertFalse(PhoneNumberUtils.areSamePhoneNumber("550-450-3605", "+15404503605", "US"));
522         assertFalse(PhoneNumberUtils.areSamePhoneNumber("550-450-3605", "+15514503605", "US"));
523 
524         assertFalse(PhoneNumberUtils.areSamePhoneNumber("+31771234567", "0771234567", "JP"));
525         assertTrue(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "+819012345678", "JP"));
526         assertTrue(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "90-1234-5678", "JP"));
527         assertFalse(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "080-1234-5678", "JP"));
528         assertFalse(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "190-1234-5678", "JP"));
529         assertFalse(PhoneNumberUtils.areSamePhoneNumber("090-1234-5678", "890-1234-5678", "JP"));
530         assertFalse(PhoneNumberUtils.areSamePhoneNumber("080-1234-5678", "+819012345678", "JP"));
531         assertFalse(PhoneNumberUtils.areSamePhoneNumber("290-1234-5678", "+819012345678", "JP"));
532 
533         //TODO: Change the expected result to false after libphonenumber improvement
534         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+79161234567", "89161234567", "RU"));
535 
536         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+33123456789", "0123456789", "FR"));
537 
538         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+31771234567", "0771234567", "NL"));
539 
540         assertTrue(PhoneNumberUtils.areSamePhoneNumber("+593(800)123-1234", "8001231234", "EC"));
541     }
542 }
543