Lara Scheidegger
15 years ago
committed by
Mihaela Rosca
Mihaela Rosca
38 changed files with 2070 additions and 681 deletions
Split View
Diff Options
-
+1 -1java/build.xml
-
+21 -1java/release_notes.txt
-
+7 -3java/resources/com/google/i18n/phonenumbers/BuildMetadataFromXml.java
-
+7 -3java/resources/com/google/i18n/phonenumbers/BuildMetadataProtoFromXml.java
-
+25 -7java/resources/com/google/i18n/phonenumbers/proto/phonenumber.proto
-
+221 -80java/resources/com/google/i18n/phonenumbers/src/PhoneNumberMetaData.xml
-
+10 -2java/resources/com/google/i18n/phonenumbers/test/PhoneNumberMetaDataForTesting.xml
-
+23 -10java/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java
-
+124 -0java/src/com/google/i18n/phonenumbers/PhoneNumberMatch.java
-
+339 -0java/src/com/google/i18n/phonenumbers/PhoneNumberMatcher.java
-
+176 -59java/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java
-
+34 -3java/src/com/google/i18n/phonenumbers/Phonenumber.java
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_BF
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_BO
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_BR
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_CL
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_CO
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_CR
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_DK
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_FO
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_GE
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_KR
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_KW
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_LA
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_LU
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_MU
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_SC
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_SH
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_TR
-
BINjava/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_VE
-
+38 -4java/test/com/google/i18n/phonenumbers/AsYouTypeFormatterTest.java
-
+72 -0java/test/com/google/i18n/phonenumbers/PhoneNumberMatchTest.java
-
+540 -0java/test/com/google/i18n/phonenumbers/PhoneNumberMatcherTest.java
-
+402 -504java/test/com/google/i18n/phonenumbers/PhoneNumberUtilTest.java
-
+30 -4java/test/com/google/i18n/phonenumbers/PhonenumberTest.java
-
BINjava/test/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProtoForTesting_AR
-
BINjava/test/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProtoForTesting_DE
-
BINjava/test/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProtoForTesting_KR
+ 1
- 1
java/build.xml
View File
+ 21
- 1
java/release_notes.txt
View File
+ 7
- 3
java/resources/com/google/i18n/phonenumbers/BuildMetadataFromXml.java
View File
+ 7
- 3
java/resources/com/google/i18n/phonenumbers/BuildMetadataProtoFromXml.java
View File
+ 25
- 7
java/resources/com/google/i18n/phonenumbers/proto/phonenumber.proto
View File
+ 221
- 80
java/resources/com/google/i18n/phonenumbers/src/PhoneNumberMetaData.xml
View File
+ 10
- 2
java/resources/com/google/i18n/phonenumbers/test/PhoneNumberMetaDataForTesting.xml
View File
+ 23
- 10
java/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java
View File
+ 124
- 0
java/src/com/google/i18n/phonenumbers/PhoneNumberMatch.java
View File
| @ -0,0 +1,124 @@ | |||
| /* | |||
| * Copyright (C) 2011 Google Inc. | |||
| * | |||
| * Licensed under the Apache License, Version 2.0 (the "License"); | |||
| * you may not use this file except in compliance with the License. | |||
| * You may obtain a copy of the License at | |||
| * | |||
| * http://www.apache.org/licenses/LICENSE-2.0 | |||
| * | |||
| * Unless required by applicable law or agreed to in writing, software | |||
| * distributed under the License is distributed on an "AS IS" BASIS, | |||
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||
| * See the License for the specific language governing permissions and | |||
| * limitations under the License. | |||
| */ | |||
| package com.google.i18n.phonenumbers; | |||
| import com.google.i18n.phonenumbers.Phonenumber.PhoneNumber; | |||
| import java.util.Arrays; | |||
| /** | |||
| * The immutable match of a phone number within a piece of text. Matches may be found using | |||
| * {@link PhoneNumberUtil#findNumbers}. | |||
| * | |||
| * <p>A match consists of the {@linkplain #number() phone number} as well as the | |||
| * {@linkplain #start() start} and {@linkplain #end() end} offsets of the corresponding subsequence | |||
| * of the searched text. Use {@link #rawString()} to obtain a copy of the matched subsequence. | |||
| * | |||
| * <p>The following annotated example clarifies the relationship between the searched text, the | |||
| * match offsets, and the parsed number: | |||
| * <pre> | |||
| * CharSequence text = "Call me at +1 425 882-8080 for details."; | |||
| * RegionCode country = RegionCode.US; | |||
| * PhoneNumberUtil util = PhoneNumberUtil.getInstance(); | |||
| * | |||
| * // Find the first phone number match: | |||
| * PhoneNumberMatch m = util.findNumbers(text, country).iterator().next(); | |||
| * | |||
| * // rawString() contains the phone number as it appears in the text. | |||
| * "+1 425 882-8080".equals(m.rawString()); | |||
| * | |||
| * // start() and end() define the range of the matched subsequence. | |||
| * CharSequence subsequence = text.subSequence(m.start(), m.end()); | |||
| * "+1 425 882-8080".contentEquals(subsequence); | |||
| * | |||
| * // number() returns the the same result as PhoneNumberUtil.{@link PhoneNumberUtil#parse parse()} | |||
| * // invoked on rawString(). | |||
| * util.parse(m.rawString(), country).equals(m.number()); | |||
| * </pre> | |||
| * | |||
| * @author Tom Hofmann | |||
| */ | |||
| public final class PhoneNumberMatch { | |||
| /** The start index into the text. */ | |||
| private final int start; | |||
| /** The raw substring matched. */ | |||
| private final String match; | |||
| /** The matched phone number. */ | |||
| private final PhoneNumber number; | |||
| /** | |||
| * Creates a new match. | |||
| * | |||
| * @param start the start index into the target text | |||
| * @param match the matched substring of the target text | |||
| * @param number the matched phone number | |||
| */ | |||
| PhoneNumberMatch(int start, String match, PhoneNumber number) { | |||
| if (start < 0) { | |||
| throw new IllegalArgumentException("Start index must be >= 0."); | |||
| } | |||
| if (match == null || number == null) { | |||
| throw new NullPointerException(); | |||
| } | |||
| this.start = start; | |||
| this.match = match; | |||
| this.number = number; | |||
| } | |||
| /** Returns the phone number matched by the receiver. */ | |||
| public PhoneNumber number() { | |||
| return number; | |||
| } | |||
| /** Returns the start index of the matched phone number within the searched text. */ | |||
| public int start() { | |||
| return start; | |||
| } | |||
| /** Returns the exclusive end index of the matched phone number within the searched text. */ | |||
| public int end() { | |||
| return start + match.length(); | |||
| } | |||
| /** Returns the raw string matched as a phone number in the searched text. */ | |||
| public String rawString() { | |||
| return match; | |||
| } | |||
| @Override | |||
| public int hashCode() { | |||
| return Arrays.hashCode(new Object[]{start, match, number}); | |||
| } | |||
| @Override | |||
| public boolean equals(Object obj) { | |||
| if (this == obj) { | |||
| return true; | |||
| } | |||
| if (!(obj instanceof PhoneNumberMatch)) { | |||
| return false; | |||
| } | |||
| PhoneNumberMatch other = (PhoneNumberMatch) obj; | |||
| return match.equals(other.match) && (start == other.start) && number.equals(other.number); | |||
| } | |||
| @Override | |||
| public String toString() { | |||
| return "PhoneNumberMatch [" + start() + "," + end() + ") " + match; | |||
| } | |||
| } | |||
+ 339
- 0
java/src/com/google/i18n/phonenumbers/PhoneNumberMatcher.java
View File
| @ -0,0 +1,339 @@ | |||
| /* | |||
| * Copyright (C) 2011 Google Inc. | |||
| * | |||
| * Licensed under the Apache License, Version 2.0 (the "License"); | |||
| * you may not use this file except in compliance with the License. | |||
| * You may obtain a copy of the License at | |||
| * | |||
| * http://www.apache.org/licenses/LICENSE-2.0 | |||
| * | |||
| * Unless required by applicable law or agreed to in writing, software | |||
| * distributed under the License is distributed on an "AS IS" BASIS, | |||
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||
| * See the License for the specific language governing permissions and | |||
| * limitations under the License. | |||
| */ | |||
| package com.google.i18n.phonenumbers; | |||
| import com.google.i18n.phonenumbers.PhoneNumberUtil.Leniency; | |||
| import com.google.i18n.phonenumbers.Phonenumber.PhoneNumber; | |||
| import java.util.Iterator; | |||
| import java.util.NoSuchElementException; | |||
| import java.util.regex.Matcher; | |||
| import java.util.regex.Pattern; | |||
| /** | |||
| * A stateful class that finds and extracts telephone numbers from {@linkplain CharSequence text}. | |||
| * Instances can be created using the {@linkplain PhoneNumberUtil#findNumbers factory methods} in | |||
| * {@link PhoneNumberUtil}. | |||
| * | |||
| * <p>Vanity numbers (phone numbers using alphabetic digits such as <tt>1-800-SIX-FLAGS</tt> are | |||
| * not found. | |||
| * | |||
| * <p>This class is not thread-safe. | |||
| * | |||
| * @author Tom Hofmann | |||
| */ | |||
| final class PhoneNumberMatcher implements Iterator<PhoneNumberMatch> { | |||
| /** | |||
| * The phone number pattern used by {@link #find}, similar to | |||
| * {@code PhoneNumberUtil.VALID_PHONE_NUMBER}, but with the following differences: | |||
| * <ul> | |||
| * <li>All captures are limited in order to place an upper bound to the text matched by the | |||
| * pattern. | |||
| * <ul> | |||
| * <li>Leading punctuation / plus signs are limited. | |||
| * <li>Consecutive occurrences of punctuation are limited. | |||
| * <li>Number of digits is limited. | |||
| * </ul> | |||
| * <li>No whitespace is allowed at the start or end. | |||
| * <li>No alpha digits (vanity numbers such as 1-800-SIX-FLAGS) are currently supported. | |||
| * </ul> | |||
| */ | |||
| private static final Pattern PATTERN; | |||
| /** | |||
| * A phone number pattern that does not allow whitespace as punctuation. This pattern is only used | |||
| * in a second attempt to find a phone number occurring in the context of other numbers, such as | |||
| * when the preceding or following token is a zip code. | |||
| */ | |||
| private static final Pattern INNER; | |||
| /** | |||
| * Matches strings that look like publication pages. Example: | |||
| * <pre>Computing Complete Answers to Queries in the Presence of Limited Access Patterns. | |||
| * Chen Li. VLDB J. 12(3): 211-227 (2003).</pre> | |||
| * | |||
| * The string "211-227 (2003)" is not a telephone number. | |||
| */ | |||
| private static final Pattern PUB_PAGES = Pattern.compile("\\d{1,5}-+\\d{1,5}\\s{0,4}\\(\\d{1,4}"); | |||
| static { | |||
| /* Builds the PATTERN and INNER regular expression patterns. The building blocks below | |||
| * exist to make the patterns more easily understood. */ | |||
| /* Limit on the number of leading (plus) characters. */ | |||
| String leadLimit = limit(0, 2); | |||
| /* Limit on the number of consecutive punctuation characters. */ | |||
| String punctuationLimit = limit(0, 4); | |||
| /* The maximum number of digits allowed in a digit-separated block. As we allow all digits in a | |||
| * single block, set high enough to accommodate the entire national number and the international | |||
| * country code. */ | |||
| int digitBlockLimit = | |||
| PhoneNumberUtil.MAX_LENGTH_FOR_NSN + PhoneNumberUtil.MAX_LENGTH_COUNTRY_CODE; | |||
| /* Limit on the number of blocks separated by punctuation. Use digitBlockLimit since in some | |||
| * formats use spaces to separate each digit. */ | |||
| String blockLimit = limit(0, digitBlockLimit); | |||
| /* Same as {@link PhoneNumberUtil#VALID_PUNCTUATION} but without space characters. */ | |||
| String nonSpacePunctuationChars = removeSpace(PhoneNumberUtil.VALID_PUNCTUATION); | |||
| /* A punctuation sequence without white space. */ | |||
| String nonSpacePunctuation = "[" + nonSpacePunctuationChars + "]" + punctuationLimit; | |||
| /* A punctuation sequence allowing white space. */ | |||
| String punctuation = "[" + PhoneNumberUtil.VALID_PUNCTUATION + "]" + punctuationLimit; | |||
| /* A digits block without punctuation. */ | |||
| String digitSequence = "\\p{Nd}" + limit(1, digitBlockLimit); | |||
| /* Punctuation that may be at the start of a phone number - brackets and plus signs. */ | |||
| String leadClass = "[(\\[" + PhoneNumberUtil.PLUS_CHARS + "]"; | |||
| /* Phone number pattern allowing optional punctuation. */ | |||
| PATTERN = Pattern.compile( | |||
| "(?:" + leadClass + punctuation + ")" + leadLimit + | |||
| digitSequence + "(?:" + punctuation + digitSequence + ")" + blockLimit + | |||
| "(?:" + PhoneNumberUtil.KNOWN_EXTN_PATTERNS + ")?", | |||
| PhoneNumberUtil.REGEX_FLAGS); | |||
| /* Phone number pattern with no whitespace allowed. */ | |||
| INNER = Pattern.compile( | |||
| leadClass + leadLimit + | |||
| digitSequence + "(?:" + nonSpacePunctuation + digitSequence + ")" + blockLimit, | |||
| PhoneNumberUtil.REGEX_FLAGS); | |||
| } | |||
| /** Returns a regular expression quantifier with an upper and lower limit. */ | |||
| private static String limit(int lower, int upper) { | |||
| if ((lower < 0) || (upper <= 0) || (upper < lower)) { | |||
| throw new IllegalArgumentException(); | |||
| } | |||
| return "{" + lower + "," + upper + "}"; | |||
| } | |||
| /** | |||
| * Returns a copy of {@code characters} with any {@linkplain Character#isSpaceChar space} | |||
| * characters removed. | |||
| */ | |||
| private static String removeSpace(String characters) { | |||
| StringBuilder builder = new StringBuilder(characters.length()); | |||
| int i = 0; | |||
| while (i < characters.length()) { | |||
| int codePoint = characters.codePointAt(i); | |||
| if (!Character.isSpaceChar(codePoint)) { | |||
| builder.appendCodePoint(codePoint); | |||
| } | |||
| i += Character.charCount(codePoint); | |||
| } | |||
| return builder.toString(); | |||
| } | |||
| /** The potential states of a PhoneNumberMatcher. */ | |||
| private enum State { | |||
| NOT_READY, READY, DONE | |||
| } | |||
| /** The phone number utility. */ | |||
| private final PhoneNumberUtil util; | |||
| /** The text searched for phone numbers. */ | |||
| private final CharSequence text; | |||
| /** | |||
| * The region (country) to assume for phone numbers without an international prefix, possibly | |||
| * null. | |||
| */ | |||
| private final String preferredRegion; | |||
| /** The degree of validation requested. */ | |||
| private final Leniency leniency; | |||
| /** The maximum number of retries after matching an invalid number. */ | |||
| private long maxTries; | |||
| /** The iteration tristate. */ | |||
| private State state = State.NOT_READY; | |||
| /** The last successful match, null unless in {@link State#READY}. */ | |||
| private PhoneNumberMatch lastMatch = null; | |||
| /** The next index to start searching at. Undefined in {@link State#DONE}. */ | |||
| private int searchIndex = 0; | |||
| /** | |||
| * Creates a new instance. See the factory methods in {@link PhoneNumberUtil} on how to obtain a | |||
| * new instance. | |||
| * | |||
| * @param util the phone number util to use | |||
| * @param text the character sequence that we will search, null for no text | |||
| * @param country the ISO 3166-1 two-letter country code indicating the country to assume for | |||
| * phone numbers not written in international format (with a leading plus, or | |||
| * with the international dialing prefix of the specified region). May be null or | |||
| * "ZZ" if only numbers with a leading plus should be considered. | |||
| * @param leniency the leniency to use when evaluating candidate phone numbers | |||
| * @param maxTries the maximum number of invalid numbers to try before giving up on the text. | |||
| * This is to cover degenerate cases where the text has a lot of false positives | |||
| * in it. Must be {@code >= 0}. | |||
| */ | |||
| PhoneNumberMatcher(PhoneNumberUtil util, CharSequence text, String country, Leniency leniency, | |||
| long maxTries) { | |||
| if ((util == null) || (leniency == null)) { | |||
| throw new NullPointerException(); | |||
| } | |||
| if (maxTries < 0) { | |||
| throw new IllegalArgumentException(); | |||
| } | |||
| this.util = util; | |||
| this.text = (text != null) ? text : ""; | |||
| this.preferredRegion = country; | |||
| this.leniency = leniency; | |||
| this.maxTries = maxTries; | |||
| } | |||
| @Override | |||
| public boolean hasNext() { | |||
| if (state == State.NOT_READY) { | |||
| lastMatch = find(searchIndex); | |||
| if (lastMatch == null) { | |||
| state = State.DONE; | |||
| } else { | |||
| searchIndex = lastMatch.end(); | |||
| state = State.READY; | |||
| } | |||
| } | |||
| return state == State.READY; | |||
| } | |||
| @Override | |||
| public PhoneNumberMatch next() { | |||
| // Check the state and find the next match as a side-effect if necessary. | |||
| if (!hasNext()) { | |||
| throw new NoSuchElementException(); | |||
| } | |||
| // Don't retain that memory any longer than necessary. | |||
| PhoneNumberMatch result = lastMatch; | |||
| lastMatch = null; | |||
| state = State.NOT_READY; | |||
| return result; | |||
| } | |||
| /** | |||
| * Attempts to find the next subsequence in the searched sequence on or after {@code searchIndex} | |||
| * that represents a phone number. Returns the next match, null if none was found. | |||
| * | |||
| * @param index the search index to start searching at | |||
| * @return the phone number match found, null if none can be found | |||
| */ | |||
| private PhoneNumberMatch find(int index) { | |||
| Matcher matcher = PATTERN.matcher(text); | |||
| while ((maxTries > 0) && matcher.find(index)) { | |||
| int start = matcher.start(); | |||
| CharSequence candidate = text.subSequence(start, matcher.end()); | |||
| // Check for extra numbers at the end. | |||
| // TODO: This is the place to start when trying to support extraction of multiple phone number | |||
| // from split notations (+41 79 123 45 67 / 68). | |||
| candidate = trimAfterFirstMatch(PhoneNumberUtil.SECOND_NUMBER_START_PATTERN, candidate); | |||
| PhoneNumberMatch match = extractMatch(candidate, start); | |||
| if (match != null) { | |||
| return match; | |||
| } | |||
| index = start + candidate.length(); | |||
| maxTries--; | |||
| } | |||
| return null; | |||
| } | |||
| /** | |||
| * Trims away any characters after the first match of {@code pattern} in {@code candidate}, | |||
| * returning the trimmed version. | |||
| */ | |||
| private static CharSequence trimAfterFirstMatch(Pattern pattern, CharSequence candidate) { | |||
| Matcher trailingCharsMatcher = pattern.matcher(candidate); | |||
| if (trailingCharsMatcher.find()) { | |||
| candidate = candidate.subSequence(0, trailingCharsMatcher.start()); | |||
| } | |||
| return candidate; | |||
| } | |||
| /** | |||
| * Attempts to extract a match from a {@code candidate} character sequence. | |||
| * | |||
| * @param candidate the candidate text that might contain a phone number | |||
| * @param offset the offset of {@code candidate} within {@link #text} | |||
| * @return the match found, null if none can be found | |||
| */ | |||
| private PhoneNumberMatch extractMatch(CharSequence candidate, int offset) { | |||
| // Skip a match that is more likely a publication page reference. | |||
| if (PUB_PAGES.matcher(candidate).find()) { | |||
| return null; | |||
| } | |||
| // Try to come up with a valid match given the entire candidate. | |||
| String rawString = candidate.toString(); | |||
| PhoneNumberMatch match = parseAndVerify(rawString, offset); | |||
| if (match != null) { | |||
| return match; | |||
| } | |||
| // If that failed, try to find an inner match without white space. | |||
| return extractInnerMatch(rawString, offset); | |||
| } | |||
| /** | |||
| * Attempts to extract a match from {@code candidate} using the {@link #INNER} pattern. | |||
| * | |||
| * @param candidate the candidate text that might contain a phone number | |||
| * @param offset the offset of {@code candidate} within {@link #text} | |||
| * @return the match found, null if none can be found | |||
| */ | |||
| private PhoneNumberMatch extractInnerMatch(String candidate, int offset) { | |||
| int index = 0; | |||
| Matcher matcher = INNER.matcher(candidate); | |||
| while ((maxTries > 0) && matcher.find(index)) { | |||
| String innerCandidate = candidate.substring(matcher.start(), matcher.end()); | |||
| PhoneNumberMatch match = parseAndVerify(innerCandidate, offset + matcher.start()); | |||
| if (match != null) { | |||
| return match; | |||
| } | |||
| maxTries--; | |||
| index = matcher.end(); | |||
| } | |||
| return null; | |||
| } | |||
| /** | |||
| * Parses a phone number from the {@code candidate} using {@link PhoneNumberUtil#parse} and | |||
| * verifies it matches the requested {@link #leniency}. If parsing and verification succeed, a | |||
| * corresponding {@link PhoneNumberMatch} is returned, otherwise this method returns null. | |||
| * | |||
| * @param candidate the candidate match | |||
| * @param offset the offset of {@code candidate} within {@link #text} | |||
| * @return the parsed and validated phone number match, or null | |||
| */ | |||
| private PhoneNumberMatch parseAndVerify(String candidate, int offset) { | |||
| try { | |||
| PhoneNumber number = util.parse(candidate, preferredRegion); | |||
| if (leniency.verify(number, util)) { | |||
| return new PhoneNumberMatch(offset, candidate, number); | |||
| } | |||
| } catch (NumberParseException e) { | |||
| // ignore and continue | |||
| } | |||
| return null; | |||
| } | |||
| /** | |||
| * Always throws {@link UnsupportedOperationException} as removal is not supported. | |||
| */ | |||
| @Override | |||
| public void remove() { | |||
| throw new UnsupportedOperationException(); | |||
| } | |||
| } | |||
+ 176
- 59
java/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java
View File
+ 34
- 3
java/src/com/google/i18n/phonenumbers/Phonenumber.java
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_BF
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_BO
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_BR
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_CL
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_CO
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_CR
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_DK
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_FO
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_GE
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_KR
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_KW
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_LA
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_LU
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_MU
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_SC
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_SH
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_TR
View File
BIN
java/src/com/google/i18n/phonenumbers/data/PhoneNumberMetadataProto_VE
View File
+ 38
- 4
java/test/com/google/i18n/phonenumbers/AsYouTypeFormatterTest.java
View File
+ 72
- 0
java/test/com/google/i18n/phonenumbers/PhoneNumberMatchTest.java
View File
| @ -0,0 +1,72 @@ | |||
| /* | |||
| * Copyright (C) 2011 Google Inc. | |||
| * | |||
| * Licensed under the Apache License, Version 2.0 (the "License"); | |||
| * you may not use this file except in compliance with the License. | |||
| * You may obtain a copy of the License at | |||
| * | |||
| * http://www.apache.org/licenses/LICENSE-2.0 | |||
| * | |||
| * Unless required by applicable law or agreed to in writing, software | |||
| * distributed under the License is distributed on an "AS IS" BASIS, | |||
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||
| * See the License for the specific language governing permissions and | |||
| * limitations under the License. | |||
| */ | |||
| package com.google.i18n.phonenumbers; | |||
| import com.google.i18n.phonenumbers.Phonenumber.PhoneNumber; | |||
| import junit.framework.TestCase; | |||
| /** | |||
| * Tests for {@link PhoneNumberMatch}. | |||
| * | |||
| * @author Tom Hofmann | |||
| */ | |||
| public class PhoneNumberMatchTest extends TestCase { | |||
| /** | |||
| * Tests the value type semantics. Equality and hash code must be based on the covered range and | |||
| * corresponding phone number. Range and number correctness are tested by | |||
| * {@link PhoneNumberMatcherTest}. | |||
| */ | |||
| public void testValueTypeSemantics() throws Exception { | |||
| PhoneNumber number = new PhoneNumber(); | |||
| PhoneNumberMatch match1 = new PhoneNumberMatch(10, "1 800 234 45 67", number); | |||
| PhoneNumberMatch match2 = new PhoneNumberMatch(10, "1 800 234 45 67", number); | |||
| assertEquals(match1, match2); | |||
| assertEquals(match1.hashCode(), match2.hashCode()); | |||
| assertEquals(match1.start(), match2.start()); | |||
| assertEquals(match1.end(), match2.end()); | |||
| assertEquals(match1.number(), match2.number()); | |||
| assertEquals(match1.rawString(), match2.rawString()); | |||
| assertEquals("1 800 234 45 67", match1.rawString()); | |||
| } | |||
| /** | |||
| * Tests the value type semantics for matches with a null number. | |||
| */ | |||
| public void testIllegalArguments() throws Exception { | |||
| try { | |||
| new PhoneNumberMatch(-110, "1 800 234 45 67", new PhoneNumber()); | |||
| fail(); | |||
| } catch (IllegalArgumentException e) { /* success */ } | |||
| try { | |||
| new PhoneNumberMatch(10, "1 800 234 45 67", null); | |||
| fail(); | |||
| } catch (NullPointerException e) { /* success */ } | |||
| try { | |||
| new PhoneNumberMatch(10, null, new PhoneNumber()); | |||
| fail(); | |||
| } catch (NullPointerException e) { /* success */ } | |||
| try { | |||
| new PhoneNumberMatch(10, null, null); | |||
| fail(); | |||
| } catch (NullPointerException e) { /* success */ } | |||
| } | |||
| } | |||
+ 540
- 0
java/test/com/google/i18n/phonenumbers/PhoneNumberMatcherTest.java
View File
| @ -0,0 +1,540 @@ | |||
| /* | |||
| * Copyright (C) 2011 Google Inc. | |||
| * | |||
| * Licensed under the Apache License, Version 2.0 (the "License"); | |||
| * you may not use this file except in compliance with the License. | |||
| * You may obtain a copy of the License at | |||
| * | |||
| * http://www.apache.org/licenses/LICENSE-2.0 | |||
| * | |||
| * Unless required by applicable law or agreed to in writing, software | |||
| * distributed under the License is distributed on an "AS IS" BASIS, | |||
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||
| * See the License for the specific language governing permissions and | |||
| * limitations under the License. | |||
| */ | |||
| package com.google.i18n.phonenumbers; | |||
| import com.google.i18n.phonenumbers.PhoneNumberUtil.Leniency; | |||
| import com.google.i18n.phonenumbers.Phonenumber.PhoneNumber; | |||
| import junit.framework.TestCase; | |||
| import java.util.ArrayList; | |||
| import java.util.Iterator; | |||
| import java.util.List; | |||
| import java.util.NoSuchElementException; | |||
| /** | |||
| * Tests for {@link PhoneNumberMatcher}. This only tests basic functionality based on test metadata. | |||
| * See {@link PhoneNumberMatcherRegressionTest} for regression tests. | |||
| * | |||
| * @author Tom Hofmann | |||
| * @see PhoneNumberUtilTest {@link PhoneNumberUtilTest} for the origin of the test data | |||
| */ | |||
| public class PhoneNumberMatcherTest extends TestCase { | |||
| private PhoneNumberUtil phoneUtil; | |||
| @Override | |||
| protected void setUp() throws Exception { | |||
| phoneUtil = PhoneNumberUtilTest.initializePhoneUtilForTesting(); | |||
| } | |||
| /** See {@link PhoneNumberUtilTest#testParseNationalNumber()}. */ | |||
| public void testFindNationalNumber() throws Exception { | |||
| // same cases as in testParseNationalNumber | |||
| doTestFindInContext("033316005", "NZ"); | |||
| doTestFindInContext("33316005", "NZ"); | |||
| // National prefix attached and some formatting present. | |||
| doTestFindInContext("03-331 6005", "NZ"); | |||
| doTestFindInContext("03 331 6005", "NZ"); | |||
| // Testing international prefixes. | |||
| // Should strip country code. | |||
| doTestFindInContext("0064 3 331 6005", "NZ"); | |||
| // Try again, but this time we have an international number with Region Code US. It should | |||
| // recognize the country code and parse accordingly. | |||
| doTestFindInContext("01164 3 331 6005", "US"); | |||
| doTestFindInContext("+64 3 331 6005", "US"); | |||
| doTestFindInContext("64(0)64123456", "NZ"); | |||
| // Check that using a "/" is fine in a phone number. | |||
| doTestFindInContext("123/45678", "DE"); | |||
| doTestFindInContext("123-456-7890", "US"); | |||
| } | |||
| /** See {@link PhoneNumberUtilTest#testParseWithInternationalPrefixes()}. */ | |||
| public void testFindWithInternationalPrefixes() throws Exception { | |||
| doTestFindInContext("+1 (650) 333-6000", "NZ"); | |||
| doTestFindInContext("1-650-333-6000", "US"); | |||
| // Calling the US number from Singapore by using different service providers | |||
| // 1st test: calling using SingTel IDD service (IDD is 001) | |||
| doTestFindInContext("0011-650-333-6000", "SG"); | |||
| // 2nd test: calling using StarHub IDD service (IDD is 008) | |||
| doTestFindInContext("0081-650-333-6000", "SG"); | |||
| // 3rd test: calling using SingTel V019 service (IDD is 019) | |||
| doTestFindInContext("0191-650-333-6000", "SG"); | |||
| // Calling the US number from Poland | |||
| doTestFindInContext("0~01-650-333-6000", "PL"); | |||
| // Using "++" at the start. | |||
| doTestFindInContext("++1 (650) 333-6000", "PL"); | |||
| // Using a full-width plus sign. | |||
| doTestFindInContext("\uFF0B1 (650) 333-6000", "SG"); | |||
| // The whole number, including punctuation, is here represented in full-width form. | |||
| doTestFindInContext("\uFF0B\uFF11\u3000\uFF08\uFF16\uFF15\uFF10\uFF09" + | |||
| "\u3000\uFF13\uFF13\uFF13\uFF0D\uFF16\uFF10\uFF10\uFF10", | |||
| "SG"); | |||
| } | |||
| /** See {@link PhoneNumberUtilTest#testParseWithLeadingZero()}. */ | |||
| public void testFindWithLeadingZero() throws Exception { | |||
| doTestFindInContext("+39 02-36618 300", "NZ"); | |||
| doTestFindInContext("02-36618 300", "IT"); | |||
| doTestFindInContext("312 345 678", "IT"); | |||
| } | |||
| /** See {@link PhoneNumberUtilTest#testParseNationalNumberArgentina()}. */ | |||
| public void testFindNationalNumberArgentina() throws Exception { | |||
| // Test parsing mobile numbers of Argentina. | |||
| doTestFindInContext("+54 9 343 555 1212", "AR"); | |||
| doTestFindInContext("0343 15 555 1212", "AR"); | |||
| doTestFindInContext("+54 9 3715 65 4320", "AR"); | |||
| doTestFindInContext("03715 15 65 4320", "AR"); | |||
| // Test parsing fixed-line numbers of Argentina. | |||
| doTestFindInContext("+54 11 3797 0000", "AR"); | |||
| doTestFindInContext("011 3797 0000", "AR"); | |||
| doTestFindInContext("+54 3715 65 4321", "AR"); | |||
| doTestFindInContext("03715 65 4321", "AR"); | |||
| doTestFindInContext("+54 23 1234 0000", "AR"); | |||
| doTestFindInContext("023 1234 0000", "AR"); | |||
| } | |||
| /** See {@link PhoneNumberUtilTest#testParseWithXInNumber()}. */ | |||
| public void testFindWithXInNumber() throws Exception { | |||
| doTestFindInContext("(0xx) 123456789", "AR"); | |||
| // This test is intentionally constructed such that the number of digit after xx is larger than | |||
| // 7, so that the number won't be mistakenly treated as an extension, as we allow extensions up | |||
| // to 7 digits. This assumption is okay for now as all the countries where a carrier selection | |||
| // code is written in the form of xx have a national significant number of length larger than 7. | |||
| doTestFindInContext("011xx5481429712", "US"); | |||
| } | |||
| /** See {@link PhoneNumberUtilTest#testParseNumbersMexico()}. */ | |||
| public void testFindNumbersMexico() throws Exception { | |||
| // Test parsing fixed-line numbers of Mexico. | |||
| doTestFindInContext("+52 (449)978-0001", "MX"); | |||
| doTestFindInContext("01 (449)978-0001", "MX"); | |||
| doTestFindInContext("(449)978-0001", "MX"); | |||
| // Test parsing mobile numbers of Mexico. | |||
| doTestFindInContext("+52 1 33 1234-5678", "MX"); | |||
| doTestFindInContext("044 (33) 1234-5678", "MX"); | |||
| doTestFindInContext("045 33 1234-5678", "MX"); | |||
| } | |||
| /** See {@link PhoneNumberUtilTest#testParseNumbersWithPlusWithNoRegion()}. */ | |||
| public void testFindNumbersWithPlusWithNoRegion() throws Exception { | |||
| // "ZZ" is allowed only if the number starts with a '+' - then the country code can be | |||
| // calculated. | |||
| doTestFindInContext("+64 3 331 6005", "ZZ"); | |||
| // Null is also allowed for the region code in these cases. | |||
| doTestFindInContext("+64 3 331 6005", null); | |||
| } | |||
| /** See {@link PhoneNumberUtilTest#testParseExtensions()}. */ | |||
| public void testFindExtensions() throws Exception { | |||
| doTestFindInContext("03 331 6005 ext 3456", "NZ"); | |||
| doTestFindInContext("03-3316005x3456", "NZ"); | |||
| doTestFindInContext("03-3316005 int.3456", "NZ"); | |||
| doTestFindInContext("03 3316005 #3456", "NZ"); | |||
| doTestFindInContext("0~0 1800 7493 524", "PL"); | |||
| doTestFindInContext("(1800) 7493.524", "US"); | |||
| // Check that the last instance of an extension token is matched. | |||
| doTestFindInContext("0~0 1800 7493 524 ~1234", "PL"); | |||
| // Verifying bug-fix where the last digit of a number was previously omitted if it was a 0 when | |||
| // extracting the extension. Also verifying a few different cases of extensions. | |||
| doTestFindInContext("+44 2034567890x456", "NZ"); | |||
| doTestFindInContext("+44 2034567890x456", "GB"); | |||
| doTestFindInContext("+44 2034567890 x456", "GB"); | |||
| doTestFindInContext("+44 2034567890 X456", "GB"); | |||
| doTestFindInContext("+44 2034567890 X 456", "GB"); | |||
| doTestFindInContext("+44 2034567890 X 456", "GB"); | |||
| doTestFindInContext("+44 2034567890 X 456", "GB"); | |||
| doTestFindInContext("(800) 901-3355 x 7246433", "US"); | |||
| doTestFindInContext("(800) 901-3355 , ext 7246433", "US"); | |||
| doTestFindInContext("(800) 901-3355 ,extension 7246433", "US"); | |||
| doTestFindInContext("(800) 901-3355 , 7246433", "US"); | |||
| doTestFindInContext("(800) 901-3355 ext: 7246433", "US"); | |||
| } | |||
| public void testFindInterspersedWithSpace() throws Exception { | |||
| doTestFindInContext("0 3 3 3 1 6 0 0 5", "NZ"); | |||
| } | |||
| /** | |||
| * Test matching behavior when starting in the middle of a phone number. | |||
| */ | |||
| public void testIntermediateParsePositions() throws Exception { | |||
| String text = "Call 033316005 or 032316005!"; | |||
| // | | | | | | | |||
| // 0 5 10 15 20 25 | |||
| // Iterate over all possible indices. | |||
| for (int i = 0; i <= 5; i++) { | |||
| assertEqualRange(text, i, 5, 14); | |||
| } | |||
| // 7 and 8 digits in a row are still parsed as number. | |||
| assertEqualRange(text, 6, 6, 14); | |||
| assertEqualRange(text, 7, 7, 14); | |||
| // Anything smaller is skipped to the second instance. | |||
| for (int i = 8; i <= 19; i++) { | |||
| assertEqualRange(text, i, 19, 28); | |||
| } | |||
| } | |||
| public void testNoMatchIfRegionIsNull() throws Exception { | |||
| // Fail on non-international prefix if region code is null. | |||
| assertTrue(hasNoMatches(phoneUtil.findNumbers( | |||
| "Random text body - number is 0331 6005, see you there", null))); | |||
| } | |||
| public void testNoMatchInEmptyString() throws Exception { | |||
| assertTrue(hasNoMatches(phoneUtil.findNumbers("", "US"))); | |||
| assertTrue(hasNoMatches(phoneUtil.findNumbers(" ", "US"))); | |||
| } | |||
| public void testNoMatchIfNoNumber() throws Exception { | |||
| assertTrue(hasNoMatches(phoneUtil.findNumbers( | |||
| "Random text body - number is foobar, see you there", "US"))); | |||
| } | |||
| public void testSequences() throws Exception { | |||
| // Test multiple occurrences. | |||
| String text = "Call 033316005 or 032316005!"; | |||
| String region = "NZ"; | |||
| PhoneNumber number1 = new PhoneNumber(); | |||
| number1.setCountryCode(phoneUtil.getCountryCodeForRegion(region)); | |||
| number1.setNationalNumber(33316005); | |||
| PhoneNumberMatch match1 = new PhoneNumberMatch(5, "033316005", number1); | |||
| PhoneNumber number2 = new PhoneNumber(); | |||
| number2.setCountryCode(phoneUtil.getCountryCodeForRegion(region)); | |||
| number2.setNationalNumber(32316005); | |||
| PhoneNumberMatch match2 = new PhoneNumberMatch(19, "032316005", number2); | |||
| Iterator<PhoneNumberMatch> matches = | |||
| phoneUtil.findNumbers(text, region, Leniency.POSSIBLE, Long.MAX_VALUE).iterator(); | |||
| assertEquals(match1, matches.next()); | |||
| assertEquals(match2, matches.next()); | |||
| } | |||
| public void testNullInput() throws Exception { | |||
| assertTrue(hasNoMatches(phoneUtil.findNumbers(null, "US"))); | |||
| assertTrue(hasNoMatches(phoneUtil.findNumbers(null, null))); | |||
| } | |||
| public void testMaxMatches() throws Exception { | |||
| // Set up text with 100 valid phone numbers. | |||
| StringBuilder numbers = new StringBuilder(); | |||
| for (int i = 0; i < 100; i++) { | |||
| numbers.append("My info: 415-666-7777,"); | |||
| } | |||
| // Matches all 100. Max only applies to failed cases. | |||
| List<PhoneNumber> expected = new ArrayList<PhoneNumber>(100); | |||
| PhoneNumber number = phoneUtil.parse("+14156667777", null); | |||
| for (int i = 0; i < 100; i++) { | |||
| expected.add(number); | |||
| } | |||
| Iterable<PhoneNumberMatch> iterable = | |||
| phoneUtil.findNumbers(numbers.toString(), "US", Leniency.VALID, 10); | |||
| List<PhoneNumber> actual = new ArrayList<PhoneNumber>(100); | |||
| for (PhoneNumberMatch match : iterable) { | |||
| actual.add(match.number()); | |||
| } | |||
| assertEquals(expected, actual); | |||
| } | |||
| public void testMaxMatchesInvalid() throws Exception { | |||
| // Set up text with 10 invalid phone numbers followed by 100 valid. | |||
| StringBuilder numbers = new StringBuilder(); | |||
| for (int i = 0; i < 10; i++) { | |||
| numbers.append("My address 949-8945-0"); | |||
| } | |||
| for (int i = 0; i < 100; i++) { | |||
| numbers.append("My info: 415-666-7777,"); | |||
| } | |||
| Iterable<PhoneNumberMatch> iterable = | |||
| phoneUtil.findNumbers(numbers.toString(), "US", Leniency.VALID, 10); | |||
| assertFalse(iterable.iterator().hasNext()); | |||
| } | |||
| public void testMaxMatchesMixed() throws Exception { | |||
| // Set up text with 100 valid numbers inside an invalid number. | |||
| StringBuilder numbers = new StringBuilder(); | |||
| for (int i = 0; i < 100; i++) { | |||
| numbers.append("My info: 415-666-7777 123 fake street"); | |||
| } | |||
| // Only matches the first 5 despite there being 100 numbers due to max matches. | |||
| // There are two false positives per line as "123" is also tried. | |||
| List<PhoneNumber> expected = new ArrayList<PhoneNumber>(100); | |||
| PhoneNumber number = phoneUtil.parse("+14156667777", null); | |||
| for (int i = 0; i < 5; i++) { | |||
| expected.add(number); | |||
| } | |||
| Iterable<PhoneNumberMatch> iterable = | |||
| phoneUtil.findNumbers(numbers.toString(), "US", Leniency.VALID, 10); | |||
| List<PhoneNumber> actual = new ArrayList<PhoneNumber>(100); | |||
| for (PhoneNumberMatch match : iterable) { | |||
| actual.add(match.number()); | |||
| } | |||
| assertEquals(expected, actual); | |||
| } | |||
| public void testEmptyIteration() throws Exception { | |||
| Iterable<PhoneNumberMatch> iterable = phoneUtil.findNumbers("", "ZZ"); | |||
| Iterator<PhoneNumberMatch> iterator = iterable.iterator(); | |||
| assertFalse(iterator.hasNext()); | |||
| assertFalse(iterator.hasNext()); | |||
| try { | |||
| iterator.next(); | |||
| fail("Violation of the Iterator contract."); | |||
| } catch (NoSuchElementException e) { /* Success */ } | |||
| assertFalse(iterator.hasNext()); | |||
| } | |||
| public void testSingleIteration() throws Exception { | |||
| Iterable<PhoneNumberMatch> iterable = phoneUtil.findNumbers("+14156667777", "ZZ"); | |||
| // With hasNext() -> next(). | |||
| Iterator<PhoneNumberMatch> iterator = iterable.iterator(); | |||
| // Double hasNext() to ensure it does not advance. | |||
| assertTrue(iterator.hasNext()); | |||
| assertTrue(iterator.hasNext()); | |||
| assertNotNull(iterator.next()); | |||
| assertFalse(iterator.hasNext()); | |||
| try { | |||
| iterator.next(); | |||
| fail("Violation of the Iterator contract."); | |||
| } catch (NoSuchElementException e) { /* Success */ } | |||
| assertFalse(iterator.hasNext()); | |||
| // With next() only. | |||
| iterator = iterable.iterator(); | |||
| assertNotNull(iterator.next()); | |||
| try { | |||
| iterator.next(); | |||
| fail("Violation of the Iterator contract."); | |||
| } catch (NoSuchElementException e) { /* Success */ } | |||
| } | |||
| public void testDoubleIteration() throws Exception { | |||
| Iterable<PhoneNumberMatch> iterable = | |||
| phoneUtil.findNumbers("+14156667777 foobar +14156667777 ", "ZZ"); | |||
| // With hasNext() -> next(). | |||
| Iterator<PhoneNumberMatch> iterator = iterable.iterator(); | |||
| // Double hasNext() to ensure it does not advance. | |||
| assertTrue(iterator.hasNext()); | |||
| assertTrue(iterator.hasNext()); | |||
| assertNotNull(iterator.next()); | |||
| assertTrue(iterator.hasNext()); | |||
| assertTrue(iterator.hasNext()); | |||
| assertNotNull(iterator.next()); | |||
| assertFalse(iterator.hasNext()); | |||
| try { | |||
| iterator.next(); | |||
| fail("Violation of the Iterator contract."); | |||
| } catch (NoSuchElementException e) { /* Success */ } | |||
| assertFalse(iterator.hasNext()); | |||
| // With next() only. | |||
| iterator = iterable.iterator(); | |||
| assertNotNull(iterator.next()); | |||
| assertNotNull(iterator.next()); | |||
| try { | |||
| iterator.next(); | |||
| fail("Violation of the Iterator contract."); | |||
| } catch (NoSuchElementException e) { /* Success */ } | |||
| } | |||
| /** | |||
| * Ensures that {@link Iterator#remove()} is not supported and that calling it does not | |||
| * change iteration behavior. | |||
| */ | |||
| public void testRemovalNotSupported() throws Exception { | |||
| Iterable<PhoneNumberMatch> iterable = phoneUtil.findNumbers("+14156667777", "ZZ"); | |||
| Iterator<PhoneNumberMatch> iterator = iterable.iterator(); | |||
| try { | |||
| iterator.remove(); | |||
| fail("Iterator must not support remove."); | |||
| } catch (UnsupportedOperationException e) { /* success */ } | |||
| assertTrue(iterator.hasNext()); | |||
| try { | |||
| iterator.remove(); | |||
| fail("Iterator must not support remove."); | |||
| } catch (UnsupportedOperationException e) { /* success */ } | |||
| assertNotNull(iterator.next()); | |||
| try { | |||
| iterator.remove(); | |||
| fail("Iterator must not support remove."); | |||
| } catch (UnsupportedOperationException e) { /* success */ } | |||
| assertFalse(iterator.hasNext()); | |||
| } | |||
| /** | |||
| * Asserts that another number can be found in {@code text} starting at {@code index}, and that | |||
| * its corresponding range is {@code [start, end)}. | |||
| */ | |||
| private void assertEqualRange(CharSequence text, int index, int start, int end) { | |||
| CharSequence sub = text.subSequence(index, text.length()); | |||
| Iterator<PhoneNumberMatch> matches = | |||
| phoneUtil.findNumbers(sub, "NZ", Leniency.POSSIBLE, Long.MAX_VALUE).iterator(); | |||
| assertTrue(matches.hasNext()); | |||
| PhoneNumberMatch match = matches.next(); | |||
| assertEquals(start - index, match.start()); | |||
| assertEquals(end - index, match.end()); | |||
| assertEquals(match.rawString(), sub.subSequence(match.start(), match.end()).toString()); | |||
| } | |||
| /** | |||
| * Tests numbers found by {@link PhoneNumberUtil#find(CharSequence, String)} in various | |||
| * textual contexts. | |||
| * | |||
| * @param number the number to test and the corresponding region code to use | |||
| */ | |||
| private void doTestFindInContext(String number, String defaultCountry) throws Exception { | |||
| findPossibleInContext(number, defaultCountry); | |||
| PhoneNumber parsed = phoneUtil.parse(number, defaultCountry); | |||
| if (phoneUtil.isValidNumber(parsed)) { | |||
| findValidInContext(number, defaultCountry); | |||
| } | |||
| } | |||
| private void findPossibleInContext(String number, String defaultCountry) { | |||
| ArrayList<NumberContext> contextPairs = new ArrayList<NumberContext>(15); | |||
| contextPairs.add(new NumberContext("", "")); // no context | |||
| contextPairs.add(new NumberContext(" ", "\t")); // whitespace only | |||
| contextPairs.add(new NumberContext("Hello ", "")); // no context at end | |||
| contextPairs.add(new NumberContext("", " to call me!")); // no context at start | |||
| contextPairs.add(new NumberContext("Hi there, call ", " to reach me!")); // no context at start | |||
| contextPairs.add(new NumberContext("Hi there, call ", ", or don't")); // with commas | |||
| // Three examples without whitespace around the number. | |||
| contextPairs.add(new NumberContext("Hi call", "")); | |||
| contextPairs.add(new NumberContext("", "forme")); | |||
| contextPairs.add(new NumberContext("Hi call", "forme")); | |||
| // With other small numbers. | |||
| contextPairs.add(new NumberContext("It's cheap! Call ", " before 6:30")); | |||
| // With a second number later. | |||
| contextPairs.add(new NumberContext("Call ", " or +1800-123-4567!")); | |||
| contextPairs.add(new NumberContext("Call me on June 21 at", "")); // with a Month-Day date | |||
| // With publication pages. | |||
| contextPairs.add(new NumberContext( | |||
| "As quoted by Alfonso 12-15 (2009), you may call me at ", "")); | |||
| contextPairs.add(new NumberContext( | |||
| "As quoted by Alfonso et al. 12-15 (2009), you may call me at ", "")); | |||
| // with a postfix stripped off as it looks like the start of another number | |||
| contextPairs.add(new NumberContext("Call ", "/x12 more")); | |||
| doTestInContext(number, defaultCountry, contextPairs, Leniency.POSSIBLE); | |||
| } | |||
| /** | |||
| * Tests valid numbers in contexts that fail for {@link Leniency#POSSIBLE}. | |||
| */ | |||
| private void findValidInContext(String number, String defaultCountry) { | |||
| ArrayList<NumberContext> contextPairs = new ArrayList<NumberContext>(5); | |||
| // With other small numbers. | |||
| contextPairs.add(new NumberContext("It's only 9.99! Call ", " to buy")); | |||
| // With a number Day.Month.Year date. | |||
| contextPairs.add(new NumberContext("Call me on 21.6.1984 at ", "")); | |||
| // With a number Month/Day date. | |||
| contextPairs.add(new NumberContext("Call me on 06/21 at ", "")); | |||
| // With a number Day.Month date | |||
| contextPairs.add(new NumberContext("Call me on 21.6. at ", "")); | |||
| // With a number Month/Day/Year date. | |||
| contextPairs.add(new NumberContext("Call me on 06/21/84 at ", "")); | |||
| doTestInContext(number, defaultCountry, contextPairs, Leniency.VALID); | |||
| } | |||
| private void doTestInContext(String number, String defaultCountry, | |||
| List<NumberContext> contextPairs, Leniency leniency) { | |||
| for (NumberContext context : contextPairs) { | |||
| String prefix = context.leadingText; | |||
| String text = prefix + number + context.trailingText; | |||
| int start = prefix.length(); | |||
| int end = start + number.length(); | |||
| Iterable<PhoneNumberMatch> iterable = | |||
| phoneUtil.findNumbers(text, defaultCountry, leniency, Long.MAX_VALUE); | |||
| PhoneNumberMatch match = iterable.iterator().hasNext() ? iterable.iterator().next() : null; | |||
| assertNotNull("Did not find a number in '" + text + "'; expected '" + number + "'", match); | |||
| CharSequence extracted = text.subSequence(match.start(), match.end()); | |||
| assertTrue("Unexpected phone region in '" + text + "'; extracted '" + extracted + "'", | |||
| start == match.start() && end == match.end()); | |||
| assertTrue(number.contentEquals(extracted)); | |||
| assertTrue(match.rawString().contentEquals(extracted)); | |||
| ensureTermination(text, defaultCountry, leniency); | |||
| } | |||
| } | |||
| /** | |||
| * Exhaustively searches for phone numbers from each index within {@code text} to test that | |||
| * finding matches always terminates. | |||
| */ | |||
| private void ensureTermination(String text, String defaultCountry, Leniency leniency) { | |||
| for (int index = 0; index <= text.length(); index++) { | |||
| String sub = text.substring(index); | |||
| StringBuffer matches = new StringBuffer(); | |||
| // Iterates over all matches. | |||
| for (PhoneNumberMatch match : | |||
| phoneUtil.findNumbers(sub, defaultCountry, leniency, Long.MAX_VALUE)) { | |||
| matches.append(", ").append(match.toString()); | |||
| } | |||
| } | |||
| } | |||
| /** | |||
| * Returns true if there were no matches found. | |||
| */ | |||
| private boolean hasNoMatches(Iterable<PhoneNumberMatch> iterable) { | |||
| return !iterable.iterator().hasNext(); | |||
| } | |||
| /** | |||
| * Small class that holds the context of the number we are testing against. The test will | |||
| * insert the phone number to be found between leadingText and trailingText. | |||
| */ | |||
| private class NumberContext { | |||
| final String leadingText; | |||
| final String trailingText; | |||
| NumberContext(String leadingText, String trailingText) { | |||
| this.leadingText = leadingText; | |||
| this.trailingText = trailingText; | |||
| } | |||
| } | |||
| } | |||