[Android] Split the address parser from AddressDetector for WebView use.

content/common/android/address_parser_unittest.cc

 // 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/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "content/common/android/address_parser.h"
+#include "content/common/android/address_parser_internal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using content::AddressDetector;
+using namespace content::address_parser;
+using namespace content::address_parser::internal;
 
-class AddressDetectorTest : public testing::Test {
+class AddressParserTest : public testing::Test {
  public:
-  AddressDetectorTest() {}
+  AddressParserTest() {}
 
-  void TokenizeWords(const string16& content,
-      AddressDetector::WordList* words) const {
-    AddressDetector::String16Tokenizer tokenizer(content.begin(),
-        content.end(), kWhitespaceUTF16);
+  void TokenizeWords(const string16& content, WordList* words) const {
+    String16Tokenizer tokenizer(content.begin(), content.end(),
+                                kWhitespaceUTF16);
     while (tokenizer.GetNext()) {
-      words->push_back(AddressDetector::Word(tokenizer.token_begin(),
-          tokenizer.token_end()));
+      words->push_back(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;
+    HouseNumberParser parser;
+    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);
+    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);
+    WordList words;
+    words.push_back(Word(tokenizer.token_begin(), tokenizer.token_end()));
+    return 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;
+    WordList words;
     TokenizeWords(zip_16, &words);
     EXPECT_TRUE(words.size() == 1);
-    return AddressDetector::IsZipValid(words.front(), state_index);
+    return ::IsZipValid(words.front(), state_index);
   }
 
   bool IsLocationName(const std::string& street) const {
     string16 street_16 = UTF8ToUTF16(street);
-    AddressDetector::WordList words;
+    WordList words;
     TokenizeWords(street_16, &words);
     EXPECT_TRUE(words.size() == 1);
-    return AddressDetector::IsValidLocationName(words.front());
+    return 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))
+    if (::FindAddress(content_16.begin(), content_16.end(), &start, &end))
       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);
+  DISALLOW_COPY_AND_ASSIGN(AddressParserTest);
 };
 
-TEST_F(AddressDetectorTest, HouseNumber) {
+TEST_F(AddressParserTest, 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");
@@ skipping 24 matching lines @@
   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) {
+TEST_F(AddressParserTest, 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) {
+TEST_F(AddressParserTest, 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"));
@@ skipping 114 matching lines @@
   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) {
+TEST_F(AddressParserTest, 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"));
@@ skipping 198 matching lines @@
   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) {
+TEST_F(AddressParserTest, 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_F(AddressParserTest, 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"));
@@ skipping 51 matching lines @@
   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(""));
 }