diff options
| -rw-r--r-- | content/content_renderer.gypi | 2 | ||||
| -rw-r--r-- | content/content_tests.gypi | 1 | ||||
| -rw-r--r-- | content/renderer/android/address_detector.cc | 836 | ||||
| -rw-r--r-- | content/renderer/android/address_detector.h | 105 | ||||
| -rw-r--r-- | content/renderer/android/address_detector_unittest.cc | 599 |
5 files changed, 1543 insertions, 0 deletions
diff --git a/content/content_renderer.gypi b/content/content_renderer.gypi index f787dc1..4896ed9 100644 --- a/content/content_renderer.gypi +++ b/content/content_renderer.gypi @@ -40,6 +40,8 @@ 'public/renderer/render_view_observer_tracker.h', 'public/renderer/render_view_visitor.h', 'public/renderer/v8_value_converter.h', + 'renderer/android/address_detector.cc', + 'renderer/android/address_detector.h', 'renderer/android/content_detector.cc', 'renderer/android/content_detector.h', 'renderer/active_notification_tracker.cc', diff --git a/content/content_tests.gypi b/content/content_tests.gypi index aea6d7d..3ed669d 100644 --- a/content/content_tests.gypi +++ b/content/content_tests.gypi @@ -284,6 +284,7 @@ 'gpu/gpu_info_collector_unittest.cc', 'gpu/gpu_info_collector_unittest_win.cc', 'renderer/active_notification_tracker_unittest.cc', + 'renderer/android/address_detector_unittest.cc', 'renderer/gpu/input_event_filter_unittest.cc', 'renderer/media/audio_message_filter_unittest.cc', 'renderer/media/capture_video_decoder_unittest.cc', diff --git a/content/renderer/android/address_detector.cc b/content/renderer/android/address_detector.cc new file mode 100644 index 0000000..fb94248 --- /dev/null +++ b/content/renderer/android/address_detector.cc @@ -0,0 +1,836 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/renderer/android/address_detector.h" + +#include <bitset> + +#include "base/string_util.h" +#include "base/utf_string_conversions.h" +#include "net/base/escape.h" +#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h" + +namespace { + +// Prefix used for geographical address intent URIs. +static const char kAddressSchemaPrefix[] = "geo:0,0?q="; + +// Maximum text length to be searched for address detection. +static const size_t kMaxAddressLength = 250; + +// Minimum number of words in an address after the house number +// before a state is expected to be found. +// A value too high can miss short addresses. +const size_t kMinAddressWords = 3; + +// Maximum number of words allowed in an address between the house number +// and the state, both not included. +const size_t kMaxAddressWords = 12; + +// Maximum number of lines allowed in an address between the house number +// and the state, both not included. +const size_t kMaxAddressLines = 5; + +// Maximum length allowed for any address word between the house number +// and the state, both not included. +const size_t kMaxAddressNameWordLength = 25; + +// Maximum number of words after the house number in which the location name +// should be found. +const size_t kMaxLocationNameDistance = 4; + +// Number of digits for a valid zip code. +const size_t kZipDigits = 5; + +// Number of digits for a valid zip code in the Zip Plus 4 format. +const size_t kZipPlus4Digits = 9; + +// Maximum number of digits of a house number, including possible hyphens. +const size_t kMaxHouseDigits = 5; + +// Additional characters used as new line delimiters. +const char16 kNewlineDelimiters[] = { + '\n', + ',', + '*', + 0x2022, // Unicode bullet +}; + +char16 SafePreviousChar(const string16::const_iterator& it, + const string16::const_iterator& begin) { + if (it == begin) + return ' '; + return *(it - 1); +} + +char16 SafeNextChar(const string16::const_iterator& it, + const string16::const_iterator& end) { + if (it == end) + return ' '; + return *(it + 1); +} + +bool WordLowerCaseEqualsASCII(string16::const_iterator word_begin, + string16::const_iterator word_end, const char* ascii_to_match) { + for (string16::const_iterator it = word_begin; it != word_end; + ++it, ++ascii_to_match) { + if (!*ascii_to_match || base::ToLowerASCII(*it) != *ascii_to_match) + return false; + } + return *ascii_to_match == 0 || *ascii_to_match == ' '; +} + +bool LowerCaseEqualsASCIIWithPlural(string16::const_iterator word_begin, + string16::const_iterator word_end, const char* ascii_to_match, + bool allow_plural) { + for (string16::const_iterator it = word_begin; it != word_end; + ++it, ++ascii_to_match) { + if (!*ascii_to_match && allow_plural && *it == 's' && it + 1 == word_end) + return true; + + if (!*ascii_to_match || base::ToLowerASCII(*it) != *ascii_to_match) + return false; + } + return *ascii_to_match == 0; +} + +} // anonymous namespace + +namespace content { + +AddressDetector::AddressDetector() { +} + +AddressDetector::~AddressDetector() { +} + +std::string AddressDetector::GetContentText(const string16& text) { + // Get the address and replace unicode bullets with commas. + string16 address_16 = CollapseWhitespace(text, false); + std::replace(address_16.begin(), address_16.end(), + static_cast<char16>(0x2022), static_cast<char16>(',')); + return UTF16ToUTF8(address_16); +} + +GURL AddressDetector::GetIntentURL(const std::string& content_text) { + return GURL(kAddressSchemaPrefix + + net::EscapeQueryParamValue(content_text, true)); +} + +size_t AddressDetector::GetMaximumContentLength() { + return kMaxAddressLength; +} + +bool AddressDetector::FindContent(const string16::const_iterator& begin, + const string16::const_iterator& end, + size_t* start_pos, + size_t* end_pos, + std::string* content_text) { + HouseNumberParser house_number_parser; + + // Keep going through the input string until a potential house number is + // detected. Start tokenizing the following words to find a valid + // street name within a word range. Then, find a state name followed + // by a valid zip code for that state. Also keep a look for any other + // possible house numbers to continue from in case of no match and for + // state names not followed by a zip code (e.g. New York, NY 10000). + const string16 newline_delimiters = kNewlineDelimiters; + const string16 delimiters = kWhitespaceUTF16 + newline_delimiters; + for (string16::const_iterator it = begin; it != end; ) { + Word house_number; + if (!house_number_parser.Parse(it, end, &house_number)) + return false; + + String16Tokenizer tokenizer(house_number.end, end, delimiters); + tokenizer.set_options(String16Tokenizer::RETURN_DELIMS); + + std::vector<Word> words; + words.push_back(house_number); + + bool found_location_name = false; + bool continue_on_house_number = true; + bool consecutive_house_numbers = true; + size_t next_house_number_word = 0; + size_t num_lines = 1; + + // Don't include the house number in the word count. + size_t next_word = 1; + for (; next_word <= kMaxAddressWords + 1; ++next_word) { + + // Extract a new word from the tokenizer. + if (next_word == words.size()) { + do { + if (!tokenizer.GetNext()) + return false; + + // Check the number of address lines. + if (tokenizer.token_is_delim() && newline_delimiters.find( + *tokenizer.token_begin()) != string16::npos) { + ++num_lines; + } + } while (tokenizer.token_is_delim()); + + if (num_lines > kMaxAddressLines) + break; + + words.push_back(Word(tokenizer.token_begin(), tokenizer.token_end())); + } + + // Check the word length. If too long, don't try to continue from + // the next house number as no address can hold this word. + const Word& current_word = words[next_word]; + DCHECK_GT(std::distance(current_word.begin, current_word.end), 0); + size_t current_word_length = std::distance( + current_word.begin, current_word.end); + if (current_word_length > kMaxAddressNameWordLength) { + continue_on_house_number = false; + break; + } + + // Check if the new word is a valid house number. + if (house_number_parser.Parse(current_word.begin, current_word.end, + NULL)) { + // Increase the number of consecutive house numbers since the beginning. + if (consecutive_house_numbers) { + // Check if there is a new line between consecutive house numbers. + // This avoids false positives of the form "Cafe 21\n 750 Fifth Ave.." + if (num_lines > 1) { + next_house_number_word = next_word; + break; + } + } + + // Keep the next candidate to resume parsing from in case of failure. + if (next_house_number_word == 0) { + next_house_number_word = next_word; + continue; + } + } else { + consecutive_house_numbers = false; + } + + // Look for location names in the words after the house number. + // A range limitation is introduced to avoid matching + // anything that starts with a number before a legitimate address. + if (next_word <= kMaxLocationNameDistance && + IsValidLocationName(current_word)) { + found_location_name = true; + continue; + } + + // Don't count the house number. + if (next_word > kMinAddressWords) { + // Looking for the state is likely to add new words to the list while + // checking for multi-word state names. + size_t state_first_word = next_word; + size_t state_last_word, state_index; + if (FindStateStartingInWord(&words, state_first_word, &state_last_word, + &tokenizer, &state_index)) { + + // A location name should have been found at this point. + if (!found_location_name) + break; + + // Explicitly exclude "et al", as "al" is a valid state code. + if (current_word_length == 2 && words.size() > 2) { + const Word& previous_word = words[state_first_word - 1]; + if (previous_word.end - previous_word.begin == 2 && + LowerCaseEqualsASCII(previous_word.begin, previous_word.end, + "et") && + LowerCaseEqualsASCII(current_word.begin, current_word.end, + "al")) + break; + } + + // Extract one more word from the tokenizer if not already available. + size_t zip_word = state_last_word + 1; + if (zip_word == words.size()) { + do { + if (!tokenizer.GetNext()) + return false; + } while (tokenizer.token_is_delim()); + words.push_back(Word(tokenizer.token_begin(), + tokenizer.token_end())); + } + + // Check the parsing validity and state range of the zip code. + next_word = state_last_word; + if (!IsZipValid(words[zip_word], state_index)) + continue; + + *start_pos = words[0].begin - begin; + *end_pos = words[zip_word].end - begin; + content_text->assign(GetContentText(string16(words[0].begin, + words[zip_word].end))); + return true; + } + } + } + + // Avoid skipping too many words because of a non-address number + // at the beginning of the contents to parse. + if (continue_on_house_number && next_house_number_word > 0) { + it = words[next_house_number_word].begin; + } else { + DCHECK(!words.empty()); + next_word = std::min(next_word, words.size() - 1); + it = words[next_word].end; + } + } + + return false; +} + +bool AddressDetector::HouseNumberParser::IsPreDelimiter( + char16 character) { + return character == ':' || IsPostDelimiter(character); +} + +bool AddressDetector::HouseNumberParser::IsPostDelimiter( + char16 character) { + return IsWhitespace(character) || strchr(",\"'", character); +} + +void AddressDetector::HouseNumberParser::RestartOnNextDelimiter() { + ResetState(); + for (; it_ != end_ && !IsPreDelimiter(*it_); ++it_) {} +} + +void AddressDetector::HouseNumberParser::AcceptChars(size_t num_chars) { + size_t offset = std::min(static_cast<size_t>(std::distance(it_, end_)), + num_chars); + it_ += offset; + result_chars_ += offset; +} + +void AddressDetector::HouseNumberParser::SkipChars(size_t num_chars) { + it_ += std::min(static_cast<size_t>(std::distance(it_, end_)), num_chars); +} + +void AddressDetector::HouseNumberParser::ResetState() { + num_digits_ = 0; + result_chars_ = 0; +} + +bool AddressDetector::HouseNumberParser::CheckFinished(Word* word) const { + // There should always be a number after a hyphen. + if (result_chars_ == 0 || SafePreviousChar(it_, begin_) == '-') + return false; + + if (word) { + word->begin = it_ - result_chars_; + word->end = it_; + } + return true; +} + +bool AddressDetector::HouseNumberParser::Parse( + const string16::const_iterator& begin, + const string16::const_iterator& end, Word* word) { + it_ = begin_ = begin; + end_ = end; + ResetState(); + + // Iterations only used as a fail-safe against any buggy infinite loops. + size_t iterations = 0; + size_t max_iterations = end - begin + 1; + for (; it_ != end_ && iterations < max_iterations; ++iterations) { + + // Word finished case. + if (IsPostDelimiter(*it_)) { + if (CheckFinished(word)) + return true; + else if (result_chars_) + ResetState(); + + SkipChars(1); + continue; + } + + // More digits. There should be no more after a letter was found. + if (IsAsciiDigit(*it_)) { + if (num_digits_ >= kMaxHouseDigits) { + RestartOnNextDelimiter(); + } else { + AcceptChars(1); + ++num_digits_; + } + continue; + } + + if (IsAsciiAlpha(*it_)) { + // Handle special case 'one'. + if (result_chars_ == 0) { + if (it_ + 3 <= end_ && LowerCaseEqualsASCII(it_, it_ + 3, "one")) + AcceptChars(3); + else + RestartOnNextDelimiter(); + continue; + } + + // There should be more than 1 character because of result_chars. + DCHECK_GT(result_chars_, 0U); + DCHECK(it_ != begin_); + char16 previous = SafePreviousChar(it_, begin_); + if (IsAsciiDigit(previous)) { + // Check cases like '12A'. + char16 next = SafeNextChar(it_, end_); + if (IsPostDelimiter(next)) { + AcceptChars(1); + continue; + } + + // Handle cases like 12a, 1st, 2nd, 3rd, 7th. + if (IsAsciiAlpha(next)) { + char16 last_digit = previous; + char16 first_letter = base::ToLowerASCII(*it_); + char16 second_letter = base::ToLowerASCII(next); + bool is_teen = SafePreviousChar(it_ - 1, begin_) == '1' && + num_digits_ == 2; + + switch (last_digit - '0') { + case 1: + if ((first_letter == 's' && second_letter == 't') || + (first_letter == 't' && second_letter == 'h' && is_teen)) { + AcceptChars(2); + continue; + } + break; + + case 2: + if ((first_letter == 'n' && second_letter == 'd') || + (first_letter == 't' && second_letter == 'h' && is_teen)) { + AcceptChars(2); + continue; + } + break; + + case 3: + if ((first_letter == 'r' && second_letter == 'd') || + (first_letter == 't' && second_letter == 'h' && is_teen)) { + AcceptChars(2); + continue; + } + break; + + case 0: + // Explicitly exclude '0th'. + if (num_digits_ == 1) + break; + + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + if (first_letter == 't' && second_letter == 'h') { + AcceptChars(2); + continue; + } + break; + + default: + NOTREACHED(); + } + } + } + + RestartOnNextDelimiter(); + continue; + } + + if (*it_ == '-' && num_digits_ > 0) { + AcceptChars(1); + ++num_digits_; + continue; + } + + RestartOnNextDelimiter(); + SkipChars(1); + } + + if (iterations >= max_iterations) + return false; + + return CheckFinished(word); +} + +bool AddressDetector::FindStateStartingInWord( + WordList* words, + size_t state_first_word, + size_t* state_last_word, + String16Tokenizer* tokenizer, + size_t* state_index) { + + // Bitmasks containing the allowed suffixes for 2-letter state codes. + static const int state_two_letter_suffix[23] = { + 0x02060c00, // A followed by: [KLRSZ]. + 0x00000000, // B. + 0x00084001, // C followed by: [AOT]. + 0x00000014, // D followed by: [CE]. + 0x00000000, // E. + 0x00001800, // F followed by: [LM]. + 0x00100001, // G followed by: [AU]. + 0x00000100, // H followed by: [I]. + 0x00002809, // I followed by: [ADLN]. + 0x00000000, // J. + 0x01040000, // K followed by: [SY]. + 0x00000001, // L followed by: [A]. + 0x000ce199, // M followed by: [ADEHINOPST]. + 0x0120129c, // N followed by: [CDEHJMVY]. + 0x00020480, // O followed by: [HKR]. + 0x00420001, // P followed by: [ARW]. + 0x00000000, // Q. + 0x00000100, // R followed by: [I]. + 0x0000000c, // S followed by: [CD]. + 0x00802000, // T followed by: [NX]. + 0x00080000, // U followed by: [T]. + 0x00080101, // V followed by: [AIT]. + 0x01200101 // W followed by: [AIVY]. + }; + + // Accumulative number of states for the 2-letter code indexed by the first. + static const int state_two_letter_accumulative[24] = { + 0, 5, 5, 8, 10, 10, 12, 14, + 15, 19, 19, 21, 22, 32, 40, 43, + 46, 46, 47, 49, 51, 52, 55, 59 + }; + + // State names sorted alphabetically with their lengths. + // There can be more than one possible name for a same state if desired. + static const struct StateNameInfo { + const char* string; + char first_word_length; + char length; + char state_index; // Relative to two-character code alphabetical order. + } state_names[59] = { + { "alabama", 7, 7, 1 }, { "alaska", 6, 6, 0 }, + { "american samoa", 8, 14, 3 }, { "arizona", 7, 7, 4 }, + { "arkansas", 8, 8, 2 }, + { "california", 10, 10, 5 }, { "colorado", 8, 8, 6 }, + { "connecticut", 11, 11, 7 }, { "delaware", 8, 8, 9 }, + { "district of columbia", 8, 20, 8 }, + { "federated states of micronesia", 9, 30, 11 }, { "florida", 7, 7, 10 }, + { "guam", 4, 4, 13 }, { "georgia", 7, 7, 12 }, + { "hawaii", 6, 6, 14 }, + { "idaho", 5, 5, 16 }, { "illinois", 8, 8, 17 }, { "indiana", 7, 7, 18 }, + { "iowa", 4, 4, 15 }, + { "kansas", 6, 6, 19 }, { "kentucky", 8, 8, 20 }, + { "louisiana", 9, 9, 21 }, + { "maine", 5, 5, 24 }, { "marshall islands", 8, 16, 25 }, + { "maryland", 8, 8, 23 }, { "massachusetts", 13, 13, 22 }, + { "michigan", 8, 8, 26 }, { "minnesota", 9, 9, 27 }, + { "mississippi", 11, 11, 30 }, { "missouri", 8, 8, 28 }, + { "montana", 7, 7, 31 }, + { "nebraska", 8, 8, 34 }, { "nevada", 6, 6, 38 }, + { "new hampshire", 3, 13, 35 }, { "new jersey", 3, 10, 36 }, + { "new mexico", 3, 10, 37 }, { "new york", 3, 8, 39 }, + { "north carolina", 5, 14, 32 }, { "north dakota", 5, 12, 33 }, + { "northern mariana islands", 8, 24, 29 }, + { "ohio", 4, 4, 40 }, { "oklahoma", 8, 8, 41 }, { "oregon", 6, 6, 42 }, + { "palau", 5, 5, 45 }, { "pennsylvania", 12, 12, 43 }, + { "puerto rico", 6, 11, 44 }, + { "rhode island", 5, 5, 46 }, + { "south carolina", 5, 14, 47 }, { "south dakota", 5, 12, 48 }, + { "tennessee", 9, 9, 49 }, { "texas", 5, 5, 50 }, + { "utah", 4, 4, 51 }, + { "vermont", 7, 7, 54 }, { "virgin islands", 6, 14, 53 }, + { "virginia", 8, 8, 52 }, + { "washington", 10, 10, 55 }, { "west virginia", 4, 13, 57 }, + { "wisconsin", 9, 9, 56 }, { "wyoming", 7, 7, 58 } + }; + + // Accumulative number of states for sorted names indexed by the first letter. + // Required a different one since there are codes that don't share their + // first letter with the name of their state (MP = Northern Mariana Islands). + static const int state_names_accumulative[24] = { + 0, 5, 5, 8, 10, 10, 12, 14, + 15, 19, 19, 21, 22, 31, 40, 43, + 46, 46, 47, 49, 51, 52, 55, 59 + }; + + DCHECK_EQ(state_names_accumulative[arraysize(state_names_accumulative) - 1], + static_cast<int>(ARRAYSIZE_UNSAFE(state_names))); + + const Word& first_word = words->at(state_first_word); + int length = first_word.end - first_word.begin; + if (length < 2 || !IsAsciiAlpha(*first_word.begin)) + return false; + + // No state names start with x, y, z. + char16 first_letter = base::ToLowerASCII(*first_word.begin); + if (first_letter > 'w') + return false; + + DCHECK(first_letter >= 'a'); + int first_index = first_letter - 'a'; + + // Look for two-letter state names. + if (length == 2 && IsAsciiAlpha(*(first_word.begin + 1))) { + char16 second_letter = base::ToLowerASCII(*(first_word.begin + 1)); + DCHECK(second_letter >= 'a'); + + int second_index = second_letter - 'a'; + if (!(state_two_letter_suffix[first_index] & (1 << second_index))) + return false; + + std::bitset<32> previous_suffixes = state_two_letter_suffix[first_index] & + ((1 << second_index) - 1); + *state_last_word = state_first_word; + *state_index = state_two_letter_accumulative[first_index] + + previous_suffixes.count(); + return true; + } + + // Look for full state names by their first letter. Discard by length. + for (int state = state_names_accumulative[first_index]; + state < state_names_accumulative[first_index + 1]; ++state) { + if (state_names[state].first_word_length != length) + continue; + + bool state_match = false; + size_t state_word = state_first_word; + for (int pos = 0; true; ) { + if (!WordLowerCaseEqualsASCII(words->at(state_word).begin, + words->at(state_word).end, &state_names[state].string[pos])) + break; + + pos += words->at(state_word).end - words->at(state_word).begin + 1; + if (pos >= state_names[state].length) { + state_match = true; + break; + } + + // Ran out of words, extract more from the tokenizer. + if (++state_word == words->size()) { + do { + if (!tokenizer->GetNext()) + break; + } while (tokenizer->token_is_delim()); + words->push_back( + Word(tokenizer->token_begin(), tokenizer->token_end())); + } + } + + if (state_match) { + *state_last_word = state_word; + *state_index = state_names[state].state_index; + return true; + } + } + + return false; +} + +bool AddressDetector::IsZipValid(const Word& word, size_t state_index) { + size_t length = word.end - word.begin; + if (length != kZipDigits && length != kZipPlus4Digits + 1) + return false; + + for (string16::const_iterator it = word.begin; it != word.end; ++it) { + size_t pos = it - word.begin; + if (IsAsciiDigit(*it) || (*it == '-' && pos == kZipDigits)) + continue; + return false; + } + return IsZipValidForState(word, state_index); +} + +bool AddressDetector::IsZipValidForState(const Word& word, size_t state_index) { + // List of valid zip code ranges. + static const struct { + char low; + char high; + char exception1; + char exception2; + } zip_range[] = { + { 99, 99, -1, -1 }, // AK Alaska. + { 35, 36, -1, -1 }, // AL Alabama. + { 71, 72, -1, -1 }, // AR Arkansas. + { 96, 96, -1, -1 }, // AS American Samoa. + { 85, 86, -1, -1 }, // AZ Arizona. + { 90, 96, -1, -1 }, // CA California. + { 80, 81, -1, -1 }, // CO Colorado. + { 6, 6, -1, -1 }, // CT Connecticut. + { 20, 20, -1, -1 }, // DC District of Columbia. + { 19, 19, -1, -1 }, // DE Delaware. + { 32, 34, -1, -1 }, // FL Florida. + { 96, 96, -1, -1 }, // FM Federated States of Micronesia. + { 30, 31, -1, -1 }, // GA Georgia. + { 96, 96, -1, -1 }, // GU Guam. + { 96, 96, -1, -1 }, // HI Hawaii. + { 50, 52, -1, -1 }, // IA Iowa. + { 83, 83, -1, -1 }, // ID Idaho. + { 60, 62, -1, -1 }, // IL Illinois. + { 46, 47, -1, -1 }, // IN Indiana. + { 66, 67, 73, -1 }, // KS Kansas. + { 40, 42, -1, -1 }, // KY Kentucky. + { 70, 71, -1, -1 }, // LA Louisiana. + { 1, 2, -1, -1 }, // MA Massachusetts. + { 20, 21, -1, -1 }, // MD Maryland. + { 3, 4, -1, -1 }, // ME Maine. + { 96, 96, -1, -1 }, // MH Marshall Islands. + { 48, 49, -1, -1 }, // MI Michigan. + { 55, 56, -1, -1 }, // MN Minnesota. + { 63, 65, -1, -1 }, // MO Missouri. + { 96, 96, -1, -1 }, // MP Northern Mariana Islands. + { 38, 39, -1, -1 }, // MS Mississippi. + { 55, 56, -1, -1 }, // MT Montana. + { 27, 28, -1, -1 }, // NC North Carolina. + { 58, 58, -1, -1 }, // ND North Dakota. + { 68, 69, -1, -1 }, // NE Nebraska. + { 3, 4, -1, -1 }, // NH New Hampshire. + { 7, 8, -1, -1 }, // NJ New Jersey. + { 87, 88, 86, -1 }, // NM New Mexico. + { 88, 89, 96, -1 }, // NV Nevada. + { 10, 14, 0, 6 }, // NY New York. + { 43, 45, -1, -1 }, // OH Ohio. + { 73, 74, -1, -1 }, // OK Oklahoma. + { 97, 97, -1, -1 }, // OR Oregon. + { 15, 19, -1, -1 }, // PA Pennsylvania. + { 6, 6, 0, 9 }, // PR Puerto Rico. + { 96, 96, -1, -1 }, // PW Palau. + { 2, 2, -1, -1 }, // RI Rhode Island. + { 29, 29, -1, -1 }, // SC South Carolina. + { 57, 57, -1, -1 }, // SD South Dakota. + { 37, 38, -1, -1 }, // TN Tennessee. + { 75, 79, 87, 88 }, // TX Texas. + { 84, 84, -1, -1 }, // UT Utah. + { 22, 24, 20, -1 }, // VA Virginia. + { 6, 9, -1, -1 }, // VI Virgin Islands. + { 5, 5, -1, -1 }, // VT Vermont. + { 98, 99, -1, -1 }, // WA Washington. + { 53, 54, -1, -1 }, // WI Wisconsin. + { 24, 26, -1, -1 }, // WV West Virginia. + { 82, 83, -1, -1 } // WY Wyoming. + }; + + // Zip numeric value for the first two characters. + DCHECK(word.begin != word.end); + DCHECK(IsAsciiDigit(*word.begin)); + DCHECK(IsAsciiDigit(*(word.begin + 1))); + int zip_prefix = (*word.begin - '0') * 10 + (*(word.begin + 1) - '0'); + + if ((zip_prefix >= zip_range[state_index].low && + zip_prefix <= zip_range[state_index].high) || + zip_prefix == zip_range[state_index].exception1 || + zip_prefix == zip_range[state_index].exception2) { + return true; + } + return false; +} + +bool AddressDetector::IsValidLocationName(const Word& word) { + // Supported location names sorted alphabetically and grouped by first letter. + static const struct LocationNameInfo { + const char* string; + char length; + bool allow_plural; + } location_names[157] = { + { "alley", 5, false }, { "annex", 5, false }, { "arcade", 6, false }, + { "ave", 3, false }, { "ave.", 4, false }, { "avenue", 6, false }, + { "alameda", 7, false }, + { "bayou", 5, false }, { "beach", 5, false }, { "bend", 4, false }, + { "bluff", 5, true }, { "bottom", 6, false }, { "boulevard", 9, false }, + { "branch", 6, false }, { "bridge", 6, false }, { "brook", 5, true }, + { "burg", 4, true }, { "bypass", 6, false }, { "broadway", 8, false }, + { "camino", 6, false }, { "camp", 4, false }, { "canyon", 6, false }, + { "cape", 4, false }, { "causeway", 8, false }, { "center", 6, true }, + { "circle", 6, true }, { "cliff", 5, true }, { "club", 4, false }, + { "common", 6, false }, { "corner", 6, true }, { "course", 6, false }, + { "court", 5, true }, { "cove", 4, true }, { "creek", 5, false }, + { "crescent", 8, false }, { "crest", 5, false }, { "crossing", 8, false }, + { "crossroad", 9, false }, { "curve", 5, false }, { "circulo", 7, false }, + { "dale", 4, false }, { "dam", 3, false }, { "divide", 6, false }, + { "drive", 5, true }, + { "estate", 6, true }, { "expressway", 10, false }, + { "extension", 9, true }, + { "fall", 4, true }, { "ferry", 5, false }, { "field", 5, true }, + { "flat", 4, true }, { "ford", 4, true }, { "forest", 6, false }, + { "forge", 5, true }, { "fork", 4, true }, { "fort", 4, false }, + { "freeway", 7, false }, + { "garden", 6, true }, { "gateway", 7, false }, { "glen", 4, true }, + { "green", 5, true }, { "grove", 5, true }, + { "harbor", 6, true }, { "haven", 5, false }, { "heights", 7, false }, + { "highway", 7, false }, { "hill", 4, true }, { "hollow", 6, false }, + { "inlet", 5, false }, { "island", 6, true }, { "isle", 4, false }, + { "junction", 8, true }, + { "key", 3, true }, { "knoll", 5, true }, + { "lake", 4, true }, { "land", 4, false }, { "landing", 7, false }, + { "lane", 4, false }, { "light", 5, true }, { "loaf", 4, false }, + { "lock", 4, true }, { "lodge", 5, false }, { "loop", 4, false }, + { "mall", 4, false }, { "manor", 5, true }, { "meadow", 6, true }, + { "mews", 4, false }, { "mill", 4, true }, { "mission", 7, false }, + { "motorway", 8, false }, { "mount", 5, false }, { "mountain", 8, true }, + { "neck", 4, false }, + { "orchard", 7, false }, { "oval", 4, false }, { "overpass", 8, false }, + { "park", 4, true }, { "parkway", 7, true }, { "pass", 4, false }, + { "passage", 7, false }, { "path", 4, false }, { "pike", 4, false }, + { "pine", 4, true }, { "plain", 5, true }, { "plaza", 5, false }, + { "point", 5, true }, { "port", 4, true }, { "prairie", 7, false }, + { "privada", 7, false }, + { "radial", 6, false }, { "ramp", 4, false }, { "ranch", 5, false }, + { "rapid", 5, true }, { "rest", 4, false }, { "ridge", 5, true }, + { "river", 5, false }, { "road", 4, true }, { "route", 5, false }, + { "row", 3, false }, { "rue", 3, false }, { "run", 3, false }, + { "shoal", 5, true }, { "shore", 5, true }, { "skyway", 6, false }, + { "spring", 6, true }, { "spur", 4, true }, { "square", 6, true }, + { "station", 7, false }, { "stravenue", 9, false }, { "stream", 6, false }, + { "st", 2, false }, { "st.", 3, false }, { "street", 6, true }, + { "summit", 6, false }, { "speedway", 8, false }, + { "terrace", 7, false }, { "throughway", 10, false }, { "trace", 5, false }, + { "track", 5, false }, { "trafficway", 10, false }, { "trail", 5, false }, + { "tunnel", 6, false }, { "turnpike", 8, false }, + { "underpass", 9, false }, { "union", 5, true }, + { "valley", 6, true }, { "viaduct", 7, false }, { "view", 4, true }, + { "village", 7, true }, { "ville", 5, false }, { "vista", 5, false }, + { "walk", 4, true }, { "wall", 4, false }, { "way", 3, true }, + { "well", 4, true }, + { "xing", 4, false }, { "xrd", 3, false } + }; + + // Accumulative number of location names for each starting letter. + static const int location_names_accumulative[25] = { + 0, 7, 19, 40, 44, + 47, 57, 62, 68, 71, + 72, 74, 83, 92, 93, + 96, 109, 109, 121, 135, + 143, 145, 151, 155, 157 + }; + + DCHECK_EQ( + location_names_accumulative[arraysize(location_names_accumulative) - 1], + static_cast<int>(ARRAYSIZE_UNSAFE(location_names))); + + if (!IsAsciiAlpha(*word.begin)) + return false; + + // No location names start with y, z. + char16 first_letter = base::ToLowerASCII(*word.begin); + if (first_letter > 'x') + return false; + + DCHECK(first_letter >= 'a'); + int index = first_letter - 'a'; + int length = std::distance(word.begin, word.end); + for (int i = location_names_accumulative[index]; + i < location_names_accumulative[index + 1]; ++i) { + if (location_names[i].length != length && + (location_names[i].allow_plural && + location_names[i].length + 1 != length)) { + continue; + } + + if (LowerCaseEqualsASCIIWithPlural(word.begin, word.end, + location_names[i].string, + location_names[i].allow_plural)) { + return true; + } + } + + return false; +} + +} // namespace content diff --git a/content/renderer/android/address_detector.h b/content/renderer/android/address_detector.h new file mode 100644 index 0000000..bd6002d --- /dev/null +++ b/content/renderer/android/address_detector.h @@ -0,0 +1,105 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_RENDERER_ANDROID_ADDRESS_DETECTOR_H_ +#define CONTENT_RENDERER_ANDROID_ADDRESS_DETECTOR_H_ +#pragma once + +#include <vector> + +#include "base/string_tokenizer.h" +#include "content/renderer/android/content_detector.h" + +class AddressDetectorTest; + +namespace content { + +// Finds a geographical address (currently US only) in the given text string. +class AddressDetector : public ContentDetector { + public: + AddressDetector(); + virtual ~AddressDetector(); + + private: + friend class ::AddressDetectorTest; + + // Implementation of ContentDetector. + virtual bool FindContent(const string16::const_iterator& begin, + const string16::const_iterator& end, + size_t* start_pos, + size_t* end_pos, + std::string* content_text) OVERRIDE; + virtual GURL GetIntentURL(const std::string& content_text) OVERRIDE; + virtual size_t GetMaximumContentLength() OVERRIDE; + + std::string GetContentText(const string16& text); + + // Internal structs and classes. Required to be visible by the unit tests. + struct Word { + string16::const_iterator begin; + string16::const_iterator end; + + Word() {} + Word(const string16::const_iterator& begin_it, + const string16::const_iterator& end_it) + : begin(begin_it), + end(end_it) { + DCHECK(begin_it <= end_it); + } + }; + + class HouseNumberParser { + public: + HouseNumberParser() {} + + bool Parse(const string16::const_iterator& begin, + const string16::const_iterator& end, + Word* word); + + private: + static inline bool IsPreDelimiter(char16 character); + static inline bool IsPostDelimiter(char16 character); + inline void RestartOnNextDelimiter(); + + inline bool CheckFinished(Word* word) const; + inline void AcceptChars(size_t num_chars); + inline void SkipChars(size_t num_chars); + inline void ResetState(); + + // Iterators to the beginning, current position and ending of the string + // being currently parsed. + string16::const_iterator begin_; + string16::const_iterator it_; + string16::const_iterator end_; + + // Number of digits found in the current result candidate. + size_t num_digits_; + + // Number of characters previous to the current iterator that belong + // to the current result candidate. + size_t result_chars_; + + DISALLOW_COPY_AND_ASSIGN(HouseNumberParser); + }; + + typedef std::vector<Word> WordList; + typedef StringTokenizerT<string16, string16::const_iterator> + String16Tokenizer; + + static bool FindStateStartingInWord(WordList* words, + size_t state_first_word, + size_t* state_last_word, + String16Tokenizer* tokenizer, + size_t* state_index); + + static bool IsValidLocationName(const Word& word); + static bool IsZipValid(const Word& word, size_t state_index); + static bool IsZipValidForState(const Word& word, size_t state_index); + + DISALLOW_COPY_AND_ASSIGN(AddressDetector); +}; + +} // namespace content + +#endif // CONTENT_RENDERER_ANDROID_ADDRESS_DETECTOR_H_ diff --git a/content/renderer/android/address_detector_unittest.cc b/content/renderer/android/address_detector_unittest.cc new file mode 100644 index 0000000..0922722 --- /dev/null +++ b/content/renderer/android/address_detector_unittest.cc @@ -0,0 +1,599 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "content/renderer/android/address_detector.h" + +#include "base/memory/scoped_ptr.h" +#include "base/utf_string_conversions.h" +#include "testing/gtest/include/gtest/gtest.h" + +using content::AddressDetector; + +class AddressDetectorTest : public testing::Test { + public: + AddressDetectorTest() {} + + void TokenizeWords(const string16& content, + AddressDetector::WordList* words) const { + AddressDetector::String16Tokenizer tokenizer(content.begin(), + content.end(), kWhitespaceUTF16); + while (tokenizer.GetNext()) { + words->push_back(AddressDetector::Word(tokenizer.token_begin(), + tokenizer.token_end())); + } + } + + std::string GetHouseNumber(const std::string& content) const { + string16 content_16 = UTF8ToUTF16(content); + string16 result; + + AddressDetector::HouseNumberParser parser; + AddressDetector::Word word; + if (parser.Parse(content_16.begin(), content_16.end(), &word)) + result = string16(word.begin, word.end); + return UTF16ToUTF8(result); + } + + bool ContainsHouseNumber(const std::string& content) const { + return !GetHouseNumber(content).empty(); + } + + bool GetState(const std::string& state, size_t* state_index) const { + string16 state_16 = UTF8ToUTF16(state); + AddressDetector::String16Tokenizer tokenizer(state_16.begin(), + state_16.end(), + kWhitespaceUTF16); + if (!tokenizer.GetNext()) + return false; + + size_t state_last_word; + AddressDetector::WordList words; + words.push_back(AddressDetector::Word(tokenizer.token_begin(), + tokenizer.token_end())); + return AddressDetector::FindStateStartingInWord( + &words, 0, &state_last_word, &tokenizer, state_index); + } + + bool IsState(const std::string& state) const { + size_t state_index; + return GetState(state, &state_index); + } + + bool IsZipValid(const std::string& zip, const std::string& state) const { + size_t state_index; + EXPECT_TRUE(GetState(state, &state_index)); + + string16 zip_16 = UTF8ToUTF16(zip); + AddressDetector::WordList words; + TokenizeWords(zip_16, &words); + EXPECT_TRUE(words.size() == 1); + return AddressDetector::IsZipValid(words.front(), state_index); + } + + bool IsLocationName(const std::string& street) const { + string16 street_16 = UTF8ToUTF16(street); + AddressDetector::WordList words; + TokenizeWords(street_16, &words); + EXPECT_TRUE(words.size() == 1); + return AddressDetector::IsValidLocationName(words.front()); + } + + std::string FindAddress(const std::string& content) const { + string16 content_16 = UTF8ToUTF16(content); + string16 result_16; + size_t start, end; + AddressDetector detector; + std::string content_text; + if (detector.FindContent(content_16.begin(), content_16.end(), + &start, &end, &content_text)) + result_16 = content_16.substr(start, end - start); + return UTF16ToUTF8(result_16); + } + + bool ContainsAddress(const std::string& content) const { + return !FindAddress(content).empty(); + } + + bool IsAddress(const std::string& content) const { + return FindAddress(content) == content; + } + + private: + DISALLOW_COPY_AND_ASSIGN(AddressDetectorTest); +}; + +TEST_F(AddressDetectorTest, HouseNumber) { + // Tests cases with valid home numbers. + EXPECT_EQ(GetHouseNumber("4 my house"), "4"); + EXPECT_EQ(GetHouseNumber("Something 4 my house"), "4"); + EXPECT_EQ(GetHouseNumber("4"), "4"); + EXPECT_EQ(GetHouseNumber(" 4,5"), "4"); + EXPECT_EQ(GetHouseNumber("one"), "one"); + EXPECT_EQ(GetHouseNumber("Number One somewhere"), "One"); + EXPECT_EQ(GetHouseNumber("Testing \n4\n"), "4"); + EXPECT_EQ(GetHouseNumber("Foo 1ST"), "1ST"); + EXPECT_EQ(GetHouseNumber("Bar 2nd"), "2nd"); + EXPECT_EQ(GetHouseNumber("Blah 3rd"), "3rd"); + EXPECT_EQ(GetHouseNumber("4th"), "4th"); + EXPECT_EQ(GetHouseNumber("Blah 11th"), "11th"); + EXPECT_EQ(GetHouseNumber("Blah 12th meh"), "12th"); + EXPECT_EQ(GetHouseNumber("Blah 13th moo"), "13th"); + EXPECT_EQ(GetHouseNumber("211st"), "211st"); + EXPECT_EQ(GetHouseNumber("1A"), "1A"); + EXPECT_EQ(GetHouseNumber("number:35"), "35"); + EXPECT_EQ(GetHouseNumber("five digits at most: 12345"), "12345"); + EXPECT_EQ(GetHouseNumber("'123'"), "123"); + EXPECT_EQ(GetHouseNumber("\"123\""), "123"); + EXPECT_EQ(GetHouseNumber("\"123, something\""), "123"); + EXPECT_EQ(GetHouseNumber("Testing 12-34"), "12-34"); + EXPECT_EQ(GetHouseNumber("Testing 12-34c,d"), "12-34c"); + EXPECT_EQ(GetHouseNumber("住所は:76 Buckingham Palace Roadです"), "76"); + + // Tests cases without valid home numbers. + EXPECT_FALSE(ContainsHouseNumber("0th")); + EXPECT_FALSE(ContainsHouseNumber("25st")); + EXPECT_FALSE(ContainsHouseNumber("111th")); + EXPECT_FALSE(ContainsHouseNumber("011th")); + EXPECT_FALSE(ContainsHouseNumber("27AZ")); + EXPECT_FALSE(ContainsHouseNumber("22ºC")); + EXPECT_FALSE(ContainsHouseNumber("3.141592")); + EXPECT_FALSE(ContainsHouseNumber("more than five digits: 123456")); + EXPECT_FALSE(ContainsHouseNumber("kjhdfkajsdhf98uf93h")); + EXPECT_FALSE(ContainsHouseNumber("これはテストです。")); + EXPECT_FALSE(ContainsHouseNumber("Number On")); + EXPECT_FALSE(ContainsHouseNumber("2: foo")); + EXPECT_FALSE(ContainsHouseNumber("12-")); + EXPECT_FALSE(ContainsHouseNumber("\n\"' \t, ")); + EXPECT_FALSE(ContainsHouseNumber("")); +} + +TEST_F(AddressDetectorTest, FindState) { + // The complete set of state codes and names is tested together with their + // returned state indices in the zip code test. + EXPECT_TRUE(IsState("CALIFORNIA")); + EXPECT_TRUE(IsState("ca")); + + EXPECT_FALSE(IsState("californi")); + EXPECT_FALSE(IsState("northern mariana")); + EXPECT_FALSE(IsState("northern mariana island")); + EXPECT_FALSE(IsState("zz")); +} + +TEST_F(AddressDetectorTest, ZipCode) { + EXPECT_TRUE(IsZipValid("90000", "CA")); + EXPECT_TRUE(IsZipValid("01234", "MA")); + EXPECT_TRUE(IsZipValid("99999-9999", "Alaska")); + + EXPECT_FALSE(IsZipValid("999999999", "Alaska")); + EXPECT_FALSE(IsZipValid("9999-99999", "Alaska")); + EXPECT_FALSE(IsZipValid("999999999-", "Alaska")); + EXPECT_FALSE(IsZipValid("99999-999a", "Alaska")); + EXPECT_FALSE(IsZipValid("99999--9999", "Alaska")); + EXPECT_FALSE(IsZipValid("90000o", "CA")); + EXPECT_FALSE(IsZipValid("01234", "CA")); + EXPECT_FALSE(IsZipValid("01234-", "MA")); + + // Test the state index against the zip range table. + EXPECT_TRUE(IsZipValid("99000", "AK")); + EXPECT_TRUE(IsZipValid("99000", "Alaska")); + EXPECT_TRUE(IsZipValid("35000", "AL")); + EXPECT_TRUE(IsZipValid("36000", "Alabama")); + EXPECT_TRUE(IsZipValid("71000", "AR")); + EXPECT_TRUE(IsZipValid("72000", "Arkansas")); + EXPECT_TRUE(IsZipValid("96000", "AS")); + EXPECT_TRUE(IsZipValid("96000", "American Samoa")); + EXPECT_TRUE(IsZipValid("85000", "AZ")); + EXPECT_TRUE(IsZipValid("86000", "Arizona")); + EXPECT_TRUE(IsZipValid("90000", "CA")); + EXPECT_TRUE(IsZipValid("96000", "California")); + EXPECT_TRUE(IsZipValid("80000", "CO")); + EXPECT_TRUE(IsZipValid("81000", "Colorado")); + EXPECT_TRUE(IsZipValid("06000", "CT")); + EXPECT_TRUE(IsZipValid("06000", "Connecticut")); + EXPECT_TRUE(IsZipValid("20000", "DC")); + EXPECT_TRUE(IsZipValid("20000", "District of Columbia")); + EXPECT_TRUE(IsZipValid("19000", "DE")); + EXPECT_TRUE(IsZipValid("19000", "Delaware")); + EXPECT_TRUE(IsZipValid("32000", "FL")); + EXPECT_TRUE(IsZipValid("34000", "Florida")); + EXPECT_TRUE(IsZipValid("96000", "FM")); + EXPECT_TRUE(IsZipValid("96000", "Federated States of Micronesia")); + EXPECT_TRUE(IsZipValid("30000", "GA")); + EXPECT_TRUE(IsZipValid("31000", "Georgia")); + EXPECT_TRUE(IsZipValid("96000", "GU")); + EXPECT_TRUE(IsZipValid("96000", "Guam")); + EXPECT_TRUE(IsZipValid("96000", "HI")); + EXPECT_TRUE(IsZipValid("96000", "Hawaii")); + EXPECT_TRUE(IsZipValid("50000", "IA")); + EXPECT_TRUE(IsZipValid("52000", "Iowa")); + EXPECT_TRUE(IsZipValid("83000", "ID")); + EXPECT_TRUE(IsZipValid("83000", "Idaho")); + EXPECT_TRUE(IsZipValid("60000", "IL")); + EXPECT_TRUE(IsZipValid("62000", "Illinois")); + EXPECT_TRUE(IsZipValid("46000", "IN")); + EXPECT_TRUE(IsZipValid("47000", "Indiana")); + EXPECT_TRUE(IsZipValid("66000", "KS")); + EXPECT_TRUE(IsZipValid("67000", "Kansas")); + EXPECT_TRUE(IsZipValid("40000", "KY")); + EXPECT_TRUE(IsZipValid("42000", "Kentucky")); + EXPECT_TRUE(IsZipValid("70000", "LA")); + EXPECT_TRUE(IsZipValid("71000", "Louisiana")); + EXPECT_TRUE(IsZipValid("01000", "MA")); + EXPECT_TRUE(IsZipValid("02000", "Massachusetts")); + EXPECT_TRUE(IsZipValid("20000", "MD")); + EXPECT_TRUE(IsZipValid("21000", "Maryland")); + EXPECT_TRUE(IsZipValid("03000", "ME")); + EXPECT_TRUE(IsZipValid("04000", "Maine")); + EXPECT_TRUE(IsZipValid("96000", "MH")); + EXPECT_TRUE(IsZipValid("96000", "Marshall Islands")); + EXPECT_TRUE(IsZipValid("48000", "MI")); + EXPECT_TRUE(IsZipValid("49000", "Michigan")); + EXPECT_TRUE(IsZipValid("55000", "MN")); + EXPECT_TRUE(IsZipValid("56000", "Minnesota")); + EXPECT_TRUE(IsZipValid("63000", "MO")); + EXPECT_TRUE(IsZipValid("65000", "Missouri")); + EXPECT_TRUE(IsZipValid("96000", "MP")); + EXPECT_TRUE(IsZipValid("96000", "Northern Mariana Islands")); + EXPECT_TRUE(IsZipValid("38000", "MS")); + EXPECT_TRUE(IsZipValid("39000", "Mississippi")); + EXPECT_TRUE(IsZipValid("55000", "MT")); + EXPECT_TRUE(IsZipValid("56000", "Montana")); + EXPECT_TRUE(IsZipValid("27000", "NC")); + EXPECT_TRUE(IsZipValid("28000", "North Carolina")); + EXPECT_TRUE(IsZipValid("58000", "ND")); + EXPECT_TRUE(IsZipValid("58000", "North Dakota")); + EXPECT_TRUE(IsZipValid("68000", "NE")); + EXPECT_TRUE(IsZipValid("69000", "Nebraska")); + EXPECT_TRUE(IsZipValid("03000", "NH")); + EXPECT_TRUE(IsZipValid("04000", "New Hampshire")); + EXPECT_TRUE(IsZipValid("07000", "NJ")); + EXPECT_TRUE(IsZipValid("08000", "New Jersey")); + EXPECT_TRUE(IsZipValid("87000", "NM")); + EXPECT_TRUE(IsZipValid("88000", "New Mexico")); + EXPECT_TRUE(IsZipValid("88000", "NV")); + EXPECT_TRUE(IsZipValid("89000", "Nevada")); + EXPECT_TRUE(IsZipValid("10000", "NY")); + EXPECT_TRUE(IsZipValid("14000", "New York")); + EXPECT_TRUE(IsZipValid("43000", "OH")); + EXPECT_TRUE(IsZipValid("45000", "Ohio")); + EXPECT_TRUE(IsZipValid("73000", "OK")); + EXPECT_TRUE(IsZipValid("74000", "Oklahoma")); + EXPECT_TRUE(IsZipValid("97000", "OR")); + EXPECT_TRUE(IsZipValid("97000", "Oregon")); + EXPECT_TRUE(IsZipValid("15000", "PA")); + EXPECT_TRUE(IsZipValid("19000", "Pennsylvania")); + EXPECT_TRUE(IsZipValid("06000", "PR")); + EXPECT_TRUE(IsZipValid("06000", "Puerto Rico")); + EXPECT_TRUE(IsZipValid("96000", "PW")); + EXPECT_TRUE(IsZipValid("96000", "Palau")); + EXPECT_TRUE(IsZipValid("02000", "RI")); + EXPECT_TRUE(IsZipValid("02000", "Rhode Island")); + EXPECT_TRUE(IsZipValid("29000", "SC")); + EXPECT_TRUE(IsZipValid("29000", "South Carolina")); + EXPECT_TRUE(IsZipValid("57000", "SD")); + EXPECT_TRUE(IsZipValid("57000", "South Dakota")); + EXPECT_TRUE(IsZipValid("37000", "TN")); + EXPECT_TRUE(IsZipValid("38000", "Tennessee")); + EXPECT_TRUE(IsZipValid("75000", "TX")); + EXPECT_TRUE(IsZipValid("79000", "Texas")); + EXPECT_TRUE(IsZipValid("84000", "UT")); + EXPECT_TRUE(IsZipValid("84000", "Utah")); + EXPECT_TRUE(IsZipValid("22000", "VA")); + EXPECT_TRUE(IsZipValid("24000", "Virginia")); + EXPECT_TRUE(IsZipValid("06000", "VI")); + EXPECT_TRUE(IsZipValid("09000", "Virgin Islands")); + EXPECT_TRUE(IsZipValid("05000", "VT")); + EXPECT_TRUE(IsZipValid("05000", "Vermont")); + EXPECT_TRUE(IsZipValid("98000", "WA")); + EXPECT_TRUE(IsZipValid("99000", "Washington")); + EXPECT_TRUE(IsZipValid("53000", "WI")); + EXPECT_TRUE(IsZipValid("54000", "Wisconsin")); + EXPECT_TRUE(IsZipValid("24000", "WV")); + EXPECT_TRUE(IsZipValid("26000", "West Virginia")); + EXPECT_TRUE(IsZipValid("82000", "WY")); + EXPECT_TRUE(IsZipValid("83000", "Wyoming")); +} + +TEST_F(AddressDetectorTest, LocationName) { + EXPECT_FALSE(IsLocationName("str-eet")); + EXPECT_FALSE(IsLocationName("somewhere")); + + // Test all supported street names and expected plural cases. + EXPECT_TRUE(IsLocationName("alley")); + EXPECT_TRUE(IsLocationName("annex")); + EXPECT_TRUE(IsLocationName("arcade")); + EXPECT_TRUE(IsLocationName("ave.")); + EXPECT_TRUE(IsLocationName("avenue")); + EXPECT_TRUE(IsLocationName("alameda")); + EXPECT_TRUE(IsLocationName("bayou")); + EXPECT_TRUE(IsLocationName("beach")); + EXPECT_TRUE(IsLocationName("bend")); + EXPECT_TRUE(IsLocationName("bluff")); + EXPECT_TRUE(IsLocationName("bluffs")); + EXPECT_TRUE(IsLocationName("bottom")); + EXPECT_TRUE(IsLocationName("boulevard")); + EXPECT_TRUE(IsLocationName("branch")); + EXPECT_TRUE(IsLocationName("bridge")); + EXPECT_TRUE(IsLocationName("brook")); + EXPECT_TRUE(IsLocationName("brooks")); + EXPECT_TRUE(IsLocationName("burg")); + EXPECT_TRUE(IsLocationName("burgs")); + EXPECT_TRUE(IsLocationName("bypass")); + EXPECT_TRUE(IsLocationName("broadway")); + EXPECT_TRUE(IsLocationName("camino")); + EXPECT_TRUE(IsLocationName("camp")); + EXPECT_TRUE(IsLocationName("canyon")); + EXPECT_TRUE(IsLocationName("cape")); + EXPECT_TRUE(IsLocationName("causeway")); + EXPECT_TRUE(IsLocationName("center")); + EXPECT_TRUE(IsLocationName("centers")); + EXPECT_TRUE(IsLocationName("circle")); + EXPECT_TRUE(IsLocationName("circles")); + EXPECT_TRUE(IsLocationName("cliff")); + EXPECT_TRUE(IsLocationName("cliffs")); + EXPECT_TRUE(IsLocationName("club")); + EXPECT_TRUE(IsLocationName("common")); + EXPECT_TRUE(IsLocationName("corner")); + EXPECT_TRUE(IsLocationName("corners")); + EXPECT_TRUE(IsLocationName("course")); + EXPECT_TRUE(IsLocationName("court")); + EXPECT_TRUE(IsLocationName("courts")); + EXPECT_TRUE(IsLocationName("cove")); + EXPECT_TRUE(IsLocationName("coves")); + EXPECT_TRUE(IsLocationName("creek")); + EXPECT_TRUE(IsLocationName("crescent")); + EXPECT_TRUE(IsLocationName("crest")); + EXPECT_TRUE(IsLocationName("crossing")); + EXPECT_TRUE(IsLocationName("crossroad")); + EXPECT_TRUE(IsLocationName("curve")); + EXPECT_TRUE(IsLocationName("circulo")); + EXPECT_TRUE(IsLocationName("dale")); + EXPECT_TRUE(IsLocationName("dam")); + EXPECT_TRUE(IsLocationName("divide")); + EXPECT_TRUE(IsLocationName("drive")); + EXPECT_TRUE(IsLocationName("drives")); + EXPECT_TRUE(IsLocationName("estate")); + EXPECT_TRUE(IsLocationName("estates")); + EXPECT_TRUE(IsLocationName("expressway")); + EXPECT_TRUE(IsLocationName("extension")); + EXPECT_TRUE(IsLocationName("extensions")); + EXPECT_TRUE(IsLocationName("fall")); + EXPECT_TRUE(IsLocationName("falls")); + EXPECT_TRUE(IsLocationName("ferry")); + EXPECT_TRUE(IsLocationName("field")); + EXPECT_TRUE(IsLocationName("fields")); + EXPECT_TRUE(IsLocationName("flat")); + EXPECT_TRUE(IsLocationName("flats")); + EXPECT_TRUE(IsLocationName("ford")); + EXPECT_TRUE(IsLocationName("fords")); + EXPECT_TRUE(IsLocationName("forest")); + EXPECT_TRUE(IsLocationName("forge")); + EXPECT_TRUE(IsLocationName("forges")); + EXPECT_TRUE(IsLocationName("fork")); + EXPECT_TRUE(IsLocationName("forks")); + EXPECT_TRUE(IsLocationName("fort")); + EXPECT_TRUE(IsLocationName("freeway")); + EXPECT_TRUE(IsLocationName("garden")); + EXPECT_TRUE(IsLocationName("gardens")); + EXPECT_TRUE(IsLocationName("gateway")); + EXPECT_TRUE(IsLocationName("glen")); + EXPECT_TRUE(IsLocationName("glens")); + EXPECT_TRUE(IsLocationName("green")); + EXPECT_TRUE(IsLocationName("greens")); + EXPECT_TRUE(IsLocationName("grove")); + EXPECT_TRUE(IsLocationName("groves")); + EXPECT_TRUE(IsLocationName("harbor")); + EXPECT_TRUE(IsLocationName("harbors")); + EXPECT_TRUE(IsLocationName("haven")); + EXPECT_TRUE(IsLocationName("heights")); + EXPECT_TRUE(IsLocationName("highway")); + EXPECT_TRUE(IsLocationName("hill")); + EXPECT_TRUE(IsLocationName("hills")); + EXPECT_TRUE(IsLocationName("hollow")); + EXPECT_TRUE(IsLocationName("inlet")); + EXPECT_TRUE(IsLocationName("island")); + EXPECT_TRUE(IsLocationName("islands")); + EXPECT_TRUE(IsLocationName("isle")); + EXPECT_TRUE(IsLocationName("junction")); + EXPECT_TRUE(IsLocationName("junctions")); + EXPECT_TRUE(IsLocationName("key")); + EXPECT_TRUE(IsLocationName("keys")); + EXPECT_TRUE(IsLocationName("knoll")); + EXPECT_TRUE(IsLocationName("knolls")); + EXPECT_TRUE(IsLocationName("lake")); + EXPECT_TRUE(IsLocationName("lakes")); + EXPECT_TRUE(IsLocationName("land")); + EXPECT_TRUE(IsLocationName("landing")); + EXPECT_TRUE(IsLocationName("lane")); + EXPECT_TRUE(IsLocationName("light")); + EXPECT_TRUE(IsLocationName("lights")); + EXPECT_TRUE(IsLocationName("loaf")); + EXPECT_TRUE(IsLocationName("lock")); + EXPECT_TRUE(IsLocationName("locks")); + EXPECT_TRUE(IsLocationName("lodge")); + EXPECT_TRUE(IsLocationName("loop")); + EXPECT_TRUE(IsLocationName("mall")); + EXPECT_TRUE(IsLocationName("manor")); + EXPECT_TRUE(IsLocationName("manors")); + EXPECT_TRUE(IsLocationName("meadow")); + EXPECT_TRUE(IsLocationName("meadows")); + EXPECT_TRUE(IsLocationName("mews")); + EXPECT_TRUE(IsLocationName("mill")); + EXPECT_TRUE(IsLocationName("mills")); + EXPECT_TRUE(IsLocationName("mission")); + EXPECT_TRUE(IsLocationName("motorway")); + EXPECT_TRUE(IsLocationName("mount")); + EXPECT_TRUE(IsLocationName("mountain")); + EXPECT_TRUE(IsLocationName("mountains")); + EXPECT_TRUE(IsLocationName("neck")); + EXPECT_TRUE(IsLocationName("orchard")); + EXPECT_TRUE(IsLocationName("oval")); + EXPECT_TRUE(IsLocationName("overpass")); + EXPECT_TRUE(IsLocationName("park")); + EXPECT_TRUE(IsLocationName("parks")); + EXPECT_TRUE(IsLocationName("parkway")); + EXPECT_TRUE(IsLocationName("parkways")); + EXPECT_TRUE(IsLocationName("pass")); + EXPECT_TRUE(IsLocationName("passage")); + EXPECT_TRUE(IsLocationName("path")); + EXPECT_TRUE(IsLocationName("pike")); + EXPECT_TRUE(IsLocationName("pine")); + EXPECT_TRUE(IsLocationName("pines")); + EXPECT_TRUE(IsLocationName("plain")); + EXPECT_TRUE(IsLocationName("plains")); + EXPECT_TRUE(IsLocationName("plaza")); + EXPECT_TRUE(IsLocationName("point")); + EXPECT_TRUE(IsLocationName("points")); + EXPECT_TRUE(IsLocationName("port")); + EXPECT_TRUE(IsLocationName("ports")); + EXPECT_TRUE(IsLocationName("prairie")); + EXPECT_TRUE(IsLocationName("privada")); + EXPECT_TRUE(IsLocationName("radial")); + EXPECT_TRUE(IsLocationName("ramp")); + EXPECT_TRUE(IsLocationName("ranch")); + EXPECT_TRUE(IsLocationName("rapid")); + EXPECT_TRUE(IsLocationName("rapids")); + EXPECT_TRUE(IsLocationName("rest")); + EXPECT_TRUE(IsLocationName("ridge")); + EXPECT_TRUE(IsLocationName("ridges")); + EXPECT_TRUE(IsLocationName("river")); + EXPECT_TRUE(IsLocationName("road")); + EXPECT_TRUE(IsLocationName("roads")); + EXPECT_TRUE(IsLocationName("route")); + EXPECT_TRUE(IsLocationName("row")); + EXPECT_TRUE(IsLocationName("rue")); + EXPECT_TRUE(IsLocationName("run")); + EXPECT_TRUE(IsLocationName("shoal")); + EXPECT_TRUE(IsLocationName("shoals")); + EXPECT_TRUE(IsLocationName("shore")); + EXPECT_TRUE(IsLocationName("shores")); + EXPECT_TRUE(IsLocationName("skyway")); + EXPECT_TRUE(IsLocationName("spring")); + EXPECT_TRUE(IsLocationName("springs")); + EXPECT_TRUE(IsLocationName("spur")); + EXPECT_TRUE(IsLocationName("spurs")); + EXPECT_TRUE(IsLocationName("square")); + EXPECT_TRUE(IsLocationName("squares")); + EXPECT_TRUE(IsLocationName("station")); + EXPECT_TRUE(IsLocationName("stravenue")); + EXPECT_TRUE(IsLocationName("stream")); + EXPECT_TRUE(IsLocationName("st.")); + EXPECT_TRUE(IsLocationName("street")); + EXPECT_TRUE(IsLocationName("streets")); + EXPECT_TRUE(IsLocationName("summit")); + EXPECT_TRUE(IsLocationName("speedway")); + EXPECT_TRUE(IsLocationName("terrace")); + EXPECT_TRUE(IsLocationName("throughway")); + EXPECT_TRUE(IsLocationName("trace")); + EXPECT_TRUE(IsLocationName("track")); + EXPECT_TRUE(IsLocationName("trafficway")); + EXPECT_TRUE(IsLocationName("trail")); + EXPECT_TRUE(IsLocationName("tunnel")); + EXPECT_TRUE(IsLocationName("turnpike")); + EXPECT_TRUE(IsLocationName("underpass")); + EXPECT_TRUE(IsLocationName("union")); + EXPECT_TRUE(IsLocationName("unions")); + EXPECT_TRUE(IsLocationName("valley")); + EXPECT_TRUE(IsLocationName("valleys")); + EXPECT_TRUE(IsLocationName("viaduct")); + EXPECT_TRUE(IsLocationName("view")); + EXPECT_TRUE(IsLocationName("views")); + EXPECT_TRUE(IsLocationName("village")); + EXPECT_TRUE(IsLocationName("villages")); + EXPECT_TRUE(IsLocationName("ville")); + EXPECT_TRUE(IsLocationName("vista")); + EXPECT_TRUE(IsLocationName("walk")); + EXPECT_TRUE(IsLocationName("walks")); + EXPECT_TRUE(IsLocationName("wall")); + EXPECT_TRUE(IsLocationName("way")); + EXPECT_TRUE(IsLocationName("ways")); + EXPECT_TRUE(IsLocationName("well")); + EXPECT_TRUE(IsLocationName("wells")); + EXPECT_TRUE(IsLocationName("xing")); + EXPECT_TRUE(IsLocationName("xrd")); +} + +TEST_F(AddressDetectorTest, NumberPrefixCases) { + EXPECT_EQ(FindAddress("Cafe 21\n750 Fifth Ave. San Diego, California 92101"), + "750 Fifth Ave. San Diego, California 92101"); + EXPECT_EQ(FindAddress( + "Century City 15\n 10250 Santa Monica Boulevard Los Angeles, CA 90067"), + "10250 Santa Monica Boulevard Los Angeles, CA 90067"); + EXPECT_EQ(FindAddress("123 45\n67 My Street, Somewhere, NY 10000"), + "67 My Street, Somewhere, NY 10000"); + EXPECT_TRUE(IsAddress("123 4th Avenue, Somewhere in NY 10000")); +} + +TEST_F(AddressDetectorTest, FullAddress) { + // Test US Google corporate addresses. Expects a full string match. + EXPECT_TRUE(IsAddress("1600 Amphitheatre Parkway Mountain View, CA 94043")); + EXPECT_TRUE(IsAddress("201 S. Division St. Suite 500 Ann Arbor, MI 48104")); + EXPECT_TRUE(ContainsAddress( + "Millennium at Midtown 10 10th Street NE Suite 600 Atlanta, GA 30309")); + EXPECT_TRUE(IsAddress( + "9606 North MoPac Expressway Suite 400 Austin, TX 78759")); + EXPECT_TRUE(IsAddress("2590 Pearl Street Suite 100 Boulder, CO 80302")); + EXPECT_TRUE(IsAddress("5 Cambridge Center, Floors 3-6 Cambridge, MA 02142")); + EXPECT_TRUE(IsAddress("410 Market St Suite 415 Chapel Hill, NC 27516")); + EXPECT_TRUE(IsAddress("20 West Kinzie St. Chicago, IL 60654")); + EXPECT_TRUE(IsAddress("114 Willits Street Birmingham, MI 48009")); + EXPECT_TRUE(IsAddress("19540 Jamboree Road 2nd Floor Irvine, CA 92612")); + EXPECT_TRUE(IsAddress("747 6th Street South, Kirkland, WA 98033")); + EXPECT_TRUE(IsAddress("301 S. Blount St. Suite 301 Madison, WI 53703")); + EXPECT_TRUE(IsAddress("76 Ninth Avenue 4th Floor New York, NY 10011")); + EXPECT_TRUE(ContainsAddress( + "Chelsea Markset Space, 75 Ninth Avenue 2nd and 4th Floors New York, \ + NY 10011")); + EXPECT_TRUE(IsAddress("6425 Penn Ave. Suite 700 Pittsburgh, PA 15206")); + EXPECT_TRUE(IsAddress("1818 Library Street Suite 400 Reston, VA 20190")); + EXPECT_TRUE(IsAddress("345 Spear Street Floors 2-4 San Francisco, CA 94105")); + EXPECT_TRUE(IsAddress("604 Arizona Avenue Santa Monica, CA 90401")); + EXPECT_TRUE(IsAddress("651 N. 34th St. Seattle, WA 98103")); + EXPECT_TRUE(IsAddress( + "1101 New York Avenue, N.W. Second Floor Washington, DC 20005")); + + // Other tests. + EXPECT_TRUE(IsAddress("57th Street and Lake Shore Drive\nChicago, IL 60637")); + EXPECT_TRUE(IsAddress("308 Congress Street Boston, MA 02210")); + EXPECT_TRUE(ContainsAddress( + "Central Park West at 79th Street, New York, NY, 10024-5192")); + EXPECT_TRUE(ContainsAddress( + "Lincoln Park | 100 34th Avenue • San Francisco, CA 94121 | 41575036")); + + EXPECT_EQ(FindAddress("Lorem ipsum dolor sit amet, consectetur adipisicing " \ + "elit, sed do 1600 Amphitheatre Parkway Mountain View, CA 94043 " \ + "eiusmod tempor incididunt ut labore et dolore magna aliqua."), + "1600 Amphitheatre Parkway Mountain View, CA 94043"); + + EXPECT_EQ(FindAddress("2590 Pearl Street Suite 100 Boulder, CO 80302 6425 " \ + "Penn Ave. Suite 700 Pittsburgh, PA 15206"), + "2590 Pearl Street Suite 100 Boulder, CO 80302"); + + EXPECT_TRUE(ContainsAddress( + "住所は 1600 Amphitheatre Parkway Mountain View, CA 94043 です。")); + + EXPECT_FALSE(ContainsAddress("1 st. too-short, CA 90000")); + EXPECT_TRUE(ContainsAddress("1 st. long enough, CA 90000")); + + EXPECT_TRUE(ContainsAddress("1 st. some city in al 35000")); + EXPECT_FALSE(ContainsAddress("1 book st Aquinas et al 35000")); + + EXPECT_FALSE(ContainsAddress("1 this comes too late: street, CA 90000")); + EXPECT_TRUE(ContainsAddress("1 this is ok: street, CA 90000")); + + EXPECT_FALSE(ContainsAddress( + "1 street I love verbosity, so I'm writing an address with too many " \ + "words CA 90000")); + EXPECT_TRUE(ContainsAddress("1 street 2 3 4 5 6 7 8 9 10 11 12, CA 90000")); + + EXPECT_TRUE(IsAddress("79th Street 1st Floor New York City, NY 10024-5192")); + + EXPECT_FALSE(ContainsAddress("123 Fake Street, Springfield, Springfield")); + EXPECT_FALSE(ContainsAddress("999 Street Avenue, City, ZZ 98765")); + EXPECT_FALSE(ContainsAddress("76 Here be dragons, CA 94043")); + EXPECT_FALSE(ContainsAddress("1 This, has, too* many, lines, to, be* valid")); + EXPECT_FALSE(ContainsAddress( + "1 Supercalifragilisticexpialidocious is too long, CA 90000")); + EXPECT_FALSE(ContainsAddress("")); +} |