cpp/test/phonenumbers/asyoutypeformatter_test.cc

   1 // Copyright (C) 2011 The Libphonenumber Authors
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 // http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 // Unit tests for asyoutypeformatter.cc, ported from AsYouTypeFormatterTest.java
  16 //
  17 // Note that these tests use the test metadata, not the normal metadata file,
  18 // so should not be used for regression test purposes - these tests are
  19 // illustrative only and test functionality.
  20
  21 #include "phonenumbers/asyoutypeformatter.h"
  22
  23 #include <gtest/gtest.h>
  24
  25 #include "phonenumbers/base/logging.h"
  26 #include "phonenumbers/base/memory/scoped_ptr.h"
  27 #include "phonenumbers/default_logger.h"
  28 #include "phonenumbers/phonenumberutil.h"
  29 #include "phonenumbers/test_util.h"
  30
  31 namespace i18n {
  32 namespace phonenumbers {
  33
  34 class PhoneMetadata;
  35
  36 class AsYouTypeFormatterTest : public testing::Test {
  37  protected:
  38   AsYouTypeFormatterTest() : phone_util_(*PhoneNumberUtil::GetInstance()) {
  39     PhoneNumberUtil::GetInstance()->SetLogger(new StdoutLogger());
  40   }
  41
  42   const PhoneMetadata* GetCurrentMetadata() const {
  43     return formatter_->current_metadata_;
  44   }
  45
  46   const string& GetExtractedNationalPrefix() const {
  47     return formatter_->GetExtractedNationalPrefix();
  48   }
  49
  50   int ConvertUnicodeStringPosition(const UnicodeString& s, int pos) const {
  51     return AsYouTypeFormatter::ConvertUnicodeStringPosition(s, pos);
  52   }
  53
  54   const PhoneNumberUtil& phone_util_;
  55   scoped_ptr<AsYouTypeFormatter> formatter_;
  56   string result_;
  57
  58  private:
  59   DISALLOW_COPY_AND_ASSIGN(AsYouTypeFormatterTest);
  60 };
  61
  62 TEST_F(AsYouTypeFormatterTest, ConvertUnicodeStringPosition) {
  63   EXPECT_EQ(-1, ConvertUnicodeStringPosition(UnicodeString("12345"), 10));
  64   EXPECT_EQ(3, ConvertUnicodeStringPosition(UnicodeString("12345"), 3));
  65   EXPECT_EQ(0, ConvertUnicodeStringPosition(
  66       UnicodeString("\xEF\xBC\x95" /* "５" */), 0));
  67   EXPECT_EQ(4, ConvertUnicodeStringPosition(
  68       UnicodeString("0\xEF\xBC\x95""3" /* "0５3" */), 2));
  69   EXPECT_EQ(5, ConvertUnicodeStringPosition(
  70       UnicodeString("0\xEF\xBC\x95""3" /* "0５3" */), 3));
  71 }
  72
  73 TEST_F(AsYouTypeFormatterTest, Constructor) {
  74   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::US()));
  75
  76   EXPECT_TRUE(GetCurrentMetadata() != NULL);
  77 }
  78
  79 TEST_F(AsYouTypeFormatterTest, InvalidPlusSign) {
  80   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::GetUnknown()));
  81   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
  82   EXPECT_EQ("+4", formatter_->InputDigit('4', &result_));
  83   EXPECT_EQ("+48 ", formatter_->InputDigit('8', &result_));
  84   EXPECT_EQ("+48 8", formatter_->InputDigit('8', &result_));
  85   EXPECT_EQ("+48 88", formatter_->InputDigit('8', &result_));
  86   EXPECT_EQ("+48 88 1", formatter_->InputDigit('1', &result_));
  87   EXPECT_EQ("+48 88 12", formatter_->InputDigit('2', &result_));
  88   EXPECT_EQ("+48 88 123", formatter_->InputDigit('3', &result_));
  89   EXPECT_EQ("+48 88 123 1", formatter_->InputDigit('1', &result_));
  90   // A plus sign can only appear at the beginning of the number; otherwise, no
  91   // formatting is applied.
  92   EXPECT_EQ("+48881231+", formatter_->InputDigit('+', &result_));
  93   EXPECT_EQ("+48881231+2", formatter_->InputDigit('2', &result_));
  94 }
  95
  96 TEST_F(AsYouTypeFormatterTest, TooLongNumberMatchingMultipleLeadingDigits) {
  97   // See https://github.com/googlei18n/libphonenumber/issues/36
  98   // The bug occurred last time for countries which have two formatting rules
  99   // with exactly the same leading digits pattern but differ in length.
 100   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::GetUnknown()));
 101
 102   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 103   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
 104   EXPECT_EQ("+81 ", formatter_->InputDigit('1', &result_));
 105   EXPECT_EQ("+81 9", formatter_->InputDigit('9', &result_));
 106   EXPECT_EQ("+81 90", formatter_->InputDigit('0', &result_));
 107   EXPECT_EQ("+81 90 1", formatter_->InputDigit('1', &result_));
 108   EXPECT_EQ("+81 90 12", formatter_->InputDigit('2', &result_));
 109   EXPECT_EQ("+81 90 123", formatter_->InputDigit('3', &result_));
 110   EXPECT_EQ("+81 90 1234", formatter_->InputDigit('4', &result_));
 111   EXPECT_EQ("+81 90 1234 5", formatter_->InputDigit('5', &result_));
 112   EXPECT_EQ("+81 90 1234 56", formatter_->InputDigit('6', &result_));
 113   EXPECT_EQ("+81 90 1234 567", formatter_->InputDigit('7', &result_));
 114   EXPECT_EQ("+81 90 1234 5678", formatter_->InputDigit('8', &result_));
 115   EXPECT_EQ("+81 90 12 345 6789", formatter_->InputDigit('9', &result_));
 116   EXPECT_EQ("+81901234567890", formatter_->InputDigit('0', &result_));
 117   EXPECT_EQ("+819012345678901", formatter_->InputDigit('1', &result_));
 118 }
 119
 120 TEST_F(AsYouTypeFormatterTest, CountryWithSpaceInNationalPrefixFormattingRule) {
 121   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::BY()));
 122
 123   EXPECT_EQ("8", formatter_->InputDigit('8', &result_));
 124   EXPECT_EQ("88", formatter_->InputDigit('8', &result_));
 125   EXPECT_EQ("881", formatter_->InputDigit('1', &result_));
 126   EXPECT_EQ("8 819", formatter_->InputDigit('9', &result_));
 127   EXPECT_EQ("8 8190", formatter_->InputDigit('0', &result_));
 128   // The formatting rule for 5 digit numbers states that no space should be
 129   // present after the national prefix.
 130   EXPECT_EQ("881 901", formatter_->InputDigit('1', &result_));
 131   EXPECT_EQ("8 819 012", formatter_->InputDigit('2', &result_));
 132   // Too long, no formatting rule applies.
 133   EXPECT_EQ("88190123", formatter_->InputDigit('3', &result_));
 134 }
 135
 136 TEST_F(AsYouTypeFormatterTest,
 137        CountryWithSpaceInNationalPrefixFormattingRuleAndLongNdd) {
 138   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::BY()));
 139
 140   EXPECT_EQ("9", formatter_->InputDigit('9', &result_));
 141   EXPECT_EQ("99", formatter_->InputDigit('9', &result_));
 142   EXPECT_EQ("999", formatter_->InputDigit('9', &result_));
 143   EXPECT_EQ("9999", formatter_->InputDigit('9', &result_));
 144   EXPECT_EQ("99999 ", formatter_->InputDigit('9', &result_));
 145   EXPECT_EQ("99999 1", formatter_->InputDigit('1', &result_));
 146   EXPECT_EQ("99999 12", formatter_->InputDigit('2', &result_));
 147   EXPECT_EQ("99999 123", formatter_->InputDigit('3', &result_));
 148   EXPECT_EQ("99999 1234", formatter_->InputDigit('4', &result_));
 149   EXPECT_EQ("99999 12 345", formatter_->InputDigit('5', &result_));
 150 }
 151
 152 TEST_F(AsYouTypeFormatterTest, AYTF_US) {
 153   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::US()));
 154
 155   EXPECT_EQ("6", formatter_->InputDigit('6', &result_));
 156   EXPECT_EQ("65", formatter_->InputDigit('5', &result_));
 157   EXPECT_EQ("650", formatter_->InputDigit('0', &result_));
 158   EXPECT_EQ("650 2", formatter_->InputDigit('2', &result_));
 159   EXPECT_EQ("650 25", formatter_->InputDigit('5', &result_));
 160   EXPECT_EQ("650 253", formatter_->InputDigit('3', &result_));
 161
 162   // Note this is how a US local number (without area code) should be formatted.
 163   EXPECT_EQ("650 2532", formatter_->InputDigit('2', &result_));
 164   EXPECT_EQ("650 253 22", formatter_->InputDigit('2', &result_));
 165   EXPECT_EQ("650 253 222", formatter_->InputDigit('2', &result_));
 166   EXPECT_EQ("650 253 2222", formatter_->InputDigit('2', &result_));
 167
 168   formatter_->Clear();
 169   EXPECT_EQ("1", formatter_->InputDigit('1', &result_));
 170   EXPECT_EQ("16", formatter_->InputDigit('6', &result_));
 171   EXPECT_EQ("1 65", formatter_->InputDigit('5', &result_));
 172   EXPECT_EQ("1 650", formatter_->InputDigit('0', &result_));
 173   EXPECT_EQ("1 650 2", formatter_->InputDigit('2', &result_));
 174   EXPECT_EQ("1 650 25", formatter_->InputDigit('5', &result_));
 175   EXPECT_EQ("1 650 253", formatter_->InputDigit('3', &result_));
 176   EXPECT_EQ("1 650 253 2", formatter_->InputDigit('2', &result_));
 177   EXPECT_EQ("1 650 253 22", formatter_->InputDigit('2', &result_));
 178   EXPECT_EQ("1 650 253 222", formatter_->InputDigit('2', &result_));
 179   EXPECT_EQ("1 650 253 2222", formatter_->InputDigit('2', &result_));
 180
 181   formatter_->Clear();
 182   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 183   EXPECT_EQ("01", formatter_->InputDigit('1', &result_));
 184   EXPECT_EQ("011 ", formatter_->InputDigit('1', &result_));
 185   EXPECT_EQ("011 4", formatter_->InputDigit('4', &result_));
 186   EXPECT_EQ("011 44 ", formatter_->InputDigit('4', &result_));
 187   EXPECT_EQ("011 44 6", formatter_->InputDigit('6', &result_));
 188   EXPECT_EQ("011 44 61", formatter_->InputDigit('1', &result_));
 189   EXPECT_EQ("011 44 6 12", formatter_->InputDigit('2', &result_));
 190   EXPECT_EQ("011 44 6 123", formatter_->InputDigit('3', &result_));
 191   EXPECT_EQ("011 44 6 123 1", formatter_->InputDigit('1', &result_));
 192   EXPECT_EQ("011 44 6 123 12", formatter_->InputDigit('2', &result_));
 193   EXPECT_EQ("011 44 6 123 123", formatter_->InputDigit('3', &result_));
 194   EXPECT_EQ("011 44 6 123 123 1", formatter_->InputDigit('1', &result_));
 195   EXPECT_EQ("011 44 6 123 123 12", formatter_->InputDigit('2', &result_));
 196   EXPECT_EQ("011 44 6 123 123 123", formatter_->InputDigit('3', &result_));
 197
 198   formatter_->Clear();
 199   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 200   EXPECT_EQ("01", formatter_->InputDigit('1', &result_));
 201   EXPECT_EQ("011 ", formatter_->InputDigit('1', &result_));
 202   EXPECT_EQ("011 5", formatter_->InputDigit('5', &result_));
 203   EXPECT_EQ("011 54 ", formatter_->InputDigit('4', &result_));
 204   EXPECT_EQ("011 54 9", formatter_->InputDigit('9', &result_));
 205   EXPECT_EQ("011 54 91", formatter_->InputDigit('1', &result_));
 206   EXPECT_EQ("011 54 9 11", formatter_->InputDigit('1', &result_));
 207   EXPECT_EQ("011 54 9 11 2", formatter_->InputDigit('2', &result_));
 208   EXPECT_EQ("011 54 9 11 23", formatter_->InputDigit('3', &result_));
 209   EXPECT_EQ("011 54 9 11 231", formatter_->InputDigit('1', &result_));
 210   EXPECT_EQ("011 54 9 11 2312", formatter_->InputDigit('2', &result_));
 211   EXPECT_EQ("011 54 9 11 2312 1", formatter_->InputDigit('1', &result_));
 212   EXPECT_EQ("011 54 9 11 2312 12", formatter_->InputDigit('2', &result_));
 213   EXPECT_EQ("011 54 9 11 2312 123", formatter_->InputDigit('3', &result_));
 214   EXPECT_EQ("011 54 9 11 2312 1234", formatter_->InputDigit('4', &result_));
 215
 216   formatter_->Clear();
 217   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 218   EXPECT_EQ("01", formatter_->InputDigit('1', &result_));
 219   EXPECT_EQ("011 ", formatter_->InputDigit('1', &result_));
 220   EXPECT_EQ("011 2", formatter_->InputDigit('2', &result_));
 221   EXPECT_EQ("011 24", formatter_->InputDigit('4', &result_));
 222   EXPECT_EQ("011 244 ", formatter_->InputDigit('4', &result_));
 223   EXPECT_EQ("011 244 2", formatter_->InputDigit('2', &result_));
 224   EXPECT_EQ("011 244 28", formatter_->InputDigit('8', &result_));
 225   EXPECT_EQ("011 244 280", formatter_->InputDigit('0', &result_));
 226   EXPECT_EQ("011 244 280 0", formatter_->InputDigit('0', &result_));
 227   EXPECT_EQ("011 244 280 00", formatter_->InputDigit('0', &result_));
 228   EXPECT_EQ("011 244 280 000", formatter_->InputDigit('0', &result_));
 229   EXPECT_EQ("011 244 280 000 0", formatter_->InputDigit('0', &result_));
 230   EXPECT_EQ("011 244 280 000 00", formatter_->InputDigit('0', &result_));
 231   EXPECT_EQ("011 244 280 000 000", formatter_->InputDigit('0', &result_));
 232
 233   formatter_->Clear();
 234   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 235   EXPECT_EQ("+4", formatter_->InputDigit('4', &result_));
 236   EXPECT_EQ("+48 ", formatter_->InputDigit('8', &result_));
 237   EXPECT_EQ("+48 8", formatter_->InputDigit('8', &result_));
 238   EXPECT_EQ("+48 88", formatter_->InputDigit('8', &result_));
 239   EXPECT_EQ("+48 88 1", formatter_->InputDigit('1', &result_));
 240   EXPECT_EQ("+48 88 12", formatter_->InputDigit('2', &result_));
 241   EXPECT_EQ("+48 88 123", formatter_->InputDigit('3', &result_));
 242   EXPECT_EQ("+48 88 123 1", formatter_->InputDigit('1', &result_));
 243   EXPECT_EQ("+48 88 123 12", formatter_->InputDigit('2', &result_));
 244   EXPECT_EQ("+48 88 123 12 1", formatter_->InputDigit('1', &result_));
 245   EXPECT_EQ("+48 88 123 12 12", formatter_->InputDigit('2', &result_));
 246 }
 247
 248 TEST_F(AsYouTypeFormatterTest, AYTF_USFullWidthCharacters) {
 249   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::US()));
 250
 251   EXPECT_EQ("\xEF\xBC\x96" /* "６" */,
 252             formatter_->InputDigit(UnicodeString("\xEF\xBC\x96" /* "６" */)[0],
 253                                    &result_));
 254   EXPECT_EQ("\xEF\xBC\x96\xEF\xBC\x95" /* "６５" */,
 255             formatter_->InputDigit(UnicodeString("\xEF\xBC\x95" /* "５" */)[0],
 256                                    &result_));
 257   EXPECT_EQ("650",
 258             formatter_->InputDigit(UnicodeString("\xEF\xBC\x90" /* "０" */)[0],
 259                                    &result_));
 260   EXPECT_EQ("650 2",
 261             formatter_->InputDigit(UnicodeString("\xEF\xBC\x92" /* "２" */)[0],
 262                                    &result_));
 263   EXPECT_EQ("650 25",
 264             formatter_->InputDigit(UnicodeString("\xEF\xBC\x95" /* "５" */)[0],
 265                                    &result_));
 266   EXPECT_EQ("650 253",
 267             formatter_->InputDigit(UnicodeString("\xEF\xBC\x93" /* "３" */)[0],
 268                                    &result_));
 269   EXPECT_EQ("650 2532",
 270             formatter_->InputDigit(UnicodeString("\xEF\xBC\x92" /* "２" */)[0],
 271                                    &result_));
 272   EXPECT_EQ("650 253 22",
 273             formatter_->InputDigit(UnicodeString("\xEF\xBC\x92" /* "２" */)[0],
 274                                    &result_));
 275   EXPECT_EQ("650 253 222",
 276             formatter_->InputDigit(UnicodeString("\xEF\xBC\x92" /* "２" */)[0],
 277                                    &result_));
 278   EXPECT_EQ("650 253 2222",
 279             formatter_->InputDigit(UnicodeString("\xEF\xBC\x92" /* "２" */)[0],
 280                                    &result_));
 281 }
 282
 283 TEST_F(AsYouTypeFormatterTest, AYTF_USMobileShortCode) {
 284   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::US()));
 285
 286   EXPECT_EQ("*", formatter_->InputDigit('*', &result_));
 287   EXPECT_EQ("*1", formatter_->InputDigit('1', &result_));
 288   EXPECT_EQ("*12", formatter_->InputDigit('2', &result_));
 289   EXPECT_EQ("*121", formatter_->InputDigit('1', &result_));
 290   EXPECT_EQ("*121#", formatter_->InputDigit('#', &result_));
 291 }
 292
 293 TEST_F(AsYouTypeFormatterTest, AYTF_USVanityNumber) {
 294   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::US()));
 295
 296   EXPECT_EQ("8", formatter_->InputDigit('8', &result_));
 297   EXPECT_EQ("80", formatter_->InputDigit('0', &result_));
 298   EXPECT_EQ("800", formatter_->InputDigit('0', &result_));
 299   EXPECT_EQ("800 ", formatter_->InputDigit(' ', &result_));
 300   EXPECT_EQ("800 M", formatter_->InputDigit('M', &result_));
 301   EXPECT_EQ("800 MY", formatter_->InputDigit('Y', &result_));
 302   EXPECT_EQ("800 MY ", formatter_->InputDigit(' ', &result_));
 303   EXPECT_EQ("800 MY A", formatter_->InputDigit('A', &result_));
 304   EXPECT_EQ("800 MY AP", formatter_->InputDigit('P', &result_));
 305   EXPECT_EQ("800 MY APP", formatter_->InputDigit('P', &result_));
 306   EXPECT_EQ("800 MY APPL", formatter_->InputDigit('L', &result_));
 307   EXPECT_EQ("800 MY APPLE", formatter_->InputDigit('E', &result_));
 308 }
 309
 310 TEST_F(AsYouTypeFormatterTest, AYTFAndRememberPositionUS) {
 311   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::US()));
 312
 313   EXPECT_EQ("1", formatter_->InputDigitAndRememberPosition('1', &result_));
 314   EXPECT_EQ(1, formatter_->GetRememberedPosition());
 315
 316   EXPECT_EQ("16", formatter_->InputDigit('6', &result_));
 317   EXPECT_EQ("1 65", formatter_->InputDigit('5', &result_));
 318   EXPECT_EQ(1, formatter_->GetRememberedPosition());
 319   EXPECT_EQ("1 650", formatter_->InputDigitAndRememberPosition('0', &result_));
 320   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 321   EXPECT_EQ("1 650 2", formatter_->InputDigit('2', &result_));
 322   EXPECT_EQ("1 650 25", formatter_->InputDigit('5', &result_));
 323
 324   // Note the remembered position for digit "0" changes from 4 to 5, because a
 325   // space is now inserted in the front.
 326   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 327   EXPECT_EQ("1 650 253", formatter_->InputDigit('3', &result_));
 328   EXPECT_EQ("1 650 253 2", formatter_->InputDigit('2', &result_));
 329   EXPECT_EQ("1 650 253 22", formatter_->InputDigit('2', &result_));
 330   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 331   EXPECT_EQ("1 650 253 222", formatter_->InputDigitAndRememberPosition('2',
 332         &result_));
 333   EXPECT_EQ(13, formatter_->GetRememberedPosition());
 334   EXPECT_EQ("1 650 253 2222", formatter_->InputDigit('2', &result_));
 335   EXPECT_EQ(13, formatter_->GetRememberedPosition());
 336   EXPECT_EQ("165025322222", formatter_->InputDigit('2', &result_));
 337   EXPECT_EQ(10, formatter_->GetRememberedPosition());
 338   EXPECT_EQ("1650253222222", formatter_->InputDigit('2', &result_));
 339   EXPECT_EQ(10, formatter_->GetRememberedPosition());
 340
 341   formatter_->Clear();
 342   EXPECT_EQ("1", formatter_->InputDigit('1', &result_));
 343   EXPECT_EQ("16", formatter_->InputDigitAndRememberPosition('6', &result_));
 344   EXPECT_EQ(2, formatter_->GetRememberedPosition());
 345   EXPECT_EQ("1 65", formatter_->InputDigit('5', &result_));
 346   EXPECT_EQ("1 650", formatter_->InputDigit('0', &result_));
 347   EXPECT_EQ(3, formatter_->GetRememberedPosition());
 348   EXPECT_EQ("1 650 2", formatter_->InputDigit('2', &result_));
 349   EXPECT_EQ("1 650 25", formatter_->InputDigit('5', &result_));
 350   EXPECT_EQ(3, formatter_->GetRememberedPosition());
 351   EXPECT_EQ("1 650 253", formatter_->InputDigit('3', &result_));
 352   EXPECT_EQ("1 650 253 2", formatter_->InputDigit('2', &result_));
 353   EXPECT_EQ("1 650 253 22", formatter_->InputDigit('2', &result_));
 354   EXPECT_EQ(3, formatter_->GetRememberedPosition());
 355   EXPECT_EQ("1 650 253 222", formatter_->InputDigit('2', &result_));
 356   EXPECT_EQ("1 650 253 2222", formatter_->InputDigit('2', &result_));
 357   EXPECT_EQ("165025322222", formatter_->InputDigit('2', &result_));
 358   EXPECT_EQ(2, formatter_->GetRememberedPosition());
 359   EXPECT_EQ("1650253222222", formatter_->InputDigit('2', &result_));
 360   EXPECT_EQ(2, formatter_->GetRememberedPosition());
 361
 362   formatter_->Clear();
 363   EXPECT_EQ("6", formatter_->InputDigit('6', &result_));
 364   EXPECT_EQ("65", formatter_->InputDigit('5', &result_));
 365   EXPECT_EQ("650", formatter_->InputDigit('0', &result_));
 366   EXPECT_EQ("650 2", formatter_->InputDigit('2', &result_));
 367   EXPECT_EQ("650 25", formatter_->InputDigit('5', &result_));
 368   EXPECT_EQ("650 253", formatter_->InputDigit('3', &result_));
 369   EXPECT_EQ("650 2532",
 370             formatter_->InputDigitAndRememberPosition('2', &result_));
 371   EXPECT_EQ(8, formatter_->GetRememberedPosition());
 372   EXPECT_EQ("650 253 22", formatter_->InputDigit('2', &result_));
 373   EXPECT_EQ(9, formatter_->GetRememberedPosition());
 374   EXPECT_EQ("650 253 222", formatter_->InputDigit('2', &result_));
 375   // No more formatting when semicolon is entered.
 376   EXPECT_EQ("650253222;", formatter_->InputDigit(';', &result_));
 377   EXPECT_EQ(7, formatter_->GetRememberedPosition());
 378   EXPECT_EQ("650253222;2", formatter_->InputDigit('2', &result_));
 379
 380   formatter_->Clear();
 381   EXPECT_EQ("6", formatter_->InputDigit('6', &result_));
 382   EXPECT_EQ("65", formatter_->InputDigit('5', &result_));
 383   EXPECT_EQ("650", formatter_->InputDigit('0', &result_));
 384   // No more formatting when users choose to do their own formatting.
 385   EXPECT_EQ("650-", formatter_->InputDigit('-', &result_));
 386   EXPECT_EQ("650-2", formatter_->InputDigitAndRememberPosition('2', &result_));
 387   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 388   EXPECT_EQ("650-25", formatter_->InputDigit('5', &result_));
 389   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 390   EXPECT_EQ("650-253", formatter_->InputDigit('3', &result_));
 391   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 392   EXPECT_EQ("650-253-", formatter_->InputDigit('-', &result_));
 393   EXPECT_EQ("650-253-2", formatter_->InputDigit('2', &result_));
 394   EXPECT_EQ("650-253-22", formatter_->InputDigit('2', &result_));
 395   EXPECT_EQ("650-253-222", formatter_->InputDigit('2', &result_));
 396   EXPECT_EQ("650-253-2222", formatter_->InputDigit('2', &result_));
 397
 398   formatter_->Clear();
 399   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 400   EXPECT_EQ("01", formatter_->InputDigit('1', &result_));
 401   EXPECT_EQ("011 ", formatter_->InputDigit('1', &result_));
 402   EXPECT_EQ("011 4", formatter_->InputDigitAndRememberPosition('4', &result_));
 403   EXPECT_EQ("011 48 ", formatter_->InputDigit('8', &result_));
 404   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 405   EXPECT_EQ("011 48 8", formatter_->InputDigit('8', &result_));
 406   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 407   EXPECT_EQ("011 48 88", formatter_->InputDigit('8', &result_));
 408   EXPECT_EQ("011 48 88 1", formatter_->InputDigit('1', &result_));
 409   EXPECT_EQ("011 48 88 12", formatter_->InputDigit('2', &result_));
 410   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 411   EXPECT_EQ("011 48 88 123", formatter_->InputDigit('3', &result_));
 412   EXPECT_EQ("011 48 88 123 1", formatter_->InputDigit('1', &result_));
 413   EXPECT_EQ("011 48 88 123 12", formatter_->InputDigit('2', &result_));
 414   EXPECT_EQ("011 48 88 123 12 1", formatter_->InputDigit('1', &result_));
 415   EXPECT_EQ("011 48 88 123 12 12", formatter_->InputDigit('2', &result_));
 416
 417   formatter_->Clear();
 418   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 419   EXPECT_EQ("+1", formatter_->InputDigit('1', &result_));
 420   EXPECT_EQ("+1 6", formatter_->InputDigitAndRememberPosition('6', &result_));
 421   EXPECT_EQ("+1 65", formatter_->InputDigit('5', &result_));
 422   EXPECT_EQ("+1 650", formatter_->InputDigit('0', &result_));
 423   EXPECT_EQ(4, formatter_->GetRememberedPosition());
 424   EXPECT_EQ("+1 650 2", formatter_->InputDigit('2', &result_));
 425   EXPECT_EQ(4, formatter_->GetRememberedPosition());
 426   EXPECT_EQ("+1 650 25", formatter_->InputDigit('5', &result_));
 427   EXPECT_EQ("+1 650 253",
 428             formatter_->InputDigitAndRememberPosition('3', &result_));
 429   EXPECT_EQ("+1 650 253 2", formatter_->InputDigit('2', &result_));
 430   EXPECT_EQ("+1 650 253 22", formatter_->InputDigit('2', &result_));
 431   EXPECT_EQ("+1 650 253 222", formatter_->InputDigit('2', &result_));
 432   EXPECT_EQ(10, formatter_->GetRememberedPosition());
 433
 434   formatter_->Clear();
 435   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 436   EXPECT_EQ("+1", formatter_->InputDigit('1', &result_));
 437   EXPECT_EQ("+1 6", formatter_->InputDigitAndRememberPosition('6', &result_));
 438   EXPECT_EQ("+1 65", formatter_->InputDigit('5', &result_));
 439   EXPECT_EQ("+1 650", formatter_->InputDigit('0', &result_));
 440   EXPECT_EQ(4, formatter_->GetRememberedPosition());
 441   EXPECT_EQ("+1 650 2", formatter_->InputDigit('2', &result_));
 442   EXPECT_EQ(4, formatter_->GetRememberedPosition());
 443   EXPECT_EQ("+1 650 25", formatter_->InputDigit('5', &result_));
 444   EXPECT_EQ("+1 650 253", formatter_->InputDigit('3', &result_));
 445   EXPECT_EQ("+1 650 253 2", formatter_->InputDigit('2', &result_));
 446   EXPECT_EQ("+1 650 253 22", formatter_->InputDigit('2', &result_));
 447   EXPECT_EQ("+1 650 253 222", formatter_->InputDigit('2', &result_));
 448   EXPECT_EQ("+1650253222;", formatter_->InputDigit(';', &result_));
 449   EXPECT_EQ(3, formatter_->GetRememberedPosition());
 450 }
 451
 452 TEST_F(AsYouTypeFormatterTest, AYTF_GBFixedLine) {
 453   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::GB()));
 454
 455   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 456   EXPECT_EQ("02", formatter_->InputDigit('2', &result_));
 457   EXPECT_EQ("020", formatter_->InputDigit('0', &result_));
 458   EXPECT_EQ("020 7", formatter_->InputDigitAndRememberPosition('7', &result_));
 459   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 460   EXPECT_EQ("020 70", formatter_->InputDigit('0', &result_));
 461   EXPECT_EQ("020 703", formatter_->InputDigit('3', &result_));
 462   EXPECT_EQ(5, formatter_->GetRememberedPosition());
 463   EXPECT_EQ("020 7031", formatter_->InputDigit('1', &result_));
 464   EXPECT_EQ("020 7031 3", formatter_->InputDigit('3', &result_));
 465   EXPECT_EQ("020 7031 30", formatter_->InputDigit('0', &result_));
 466   EXPECT_EQ("020 7031 300", formatter_->InputDigit('0', &result_));
 467   EXPECT_EQ("020 7031 3000", formatter_->InputDigit('0', &result_));
 468 }
 469
 470 TEST_F(AsYouTypeFormatterTest, AYTF_GBTollFree) {
 471   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::GB()));
 472
 473   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 474   EXPECT_EQ("08", formatter_->InputDigit('8', &result_));
 475   EXPECT_EQ("080", formatter_->InputDigit('0', &result_));
 476   EXPECT_EQ("080 7", formatter_->InputDigit('7', &result_));
 477   EXPECT_EQ("080 70", formatter_->InputDigit('0', &result_));
 478   EXPECT_EQ("080 703", formatter_->InputDigit('3', &result_));
 479   EXPECT_EQ("080 7031", formatter_->InputDigit('1', &result_));
 480   EXPECT_EQ("080 7031 3", formatter_->InputDigit('3', &result_));
 481   EXPECT_EQ("080 7031 30", formatter_->InputDigit('0', &result_));
 482   EXPECT_EQ("080 7031 300", formatter_->InputDigit('0', &result_));
 483   EXPECT_EQ("080 7031 3000", formatter_->InputDigit('0', &result_));
 484 }
 485
 486 TEST_F(AsYouTypeFormatterTest, AYTF_GBPremiumRate) {
 487   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::GB()));
 488
 489   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 490   EXPECT_EQ("09", formatter_->InputDigit('9', &result_));
 491   EXPECT_EQ("090", formatter_->InputDigit('0', &result_));
 492   EXPECT_EQ("090 7", formatter_->InputDigit('7', &result_));
 493   EXPECT_EQ("090 70", formatter_->InputDigit('0', &result_));
 494   EXPECT_EQ("090 703", formatter_->InputDigit('3', &result_));
 495   EXPECT_EQ("090 7031", formatter_->InputDigit('1', &result_));
 496   EXPECT_EQ("090 7031 3", formatter_->InputDigit('3', &result_));
 497   EXPECT_EQ("090 7031 30", formatter_->InputDigit('0', &result_));
 498   EXPECT_EQ("090 7031 300", formatter_->InputDigit('0', &result_));
 499   EXPECT_EQ("090 7031 3000", formatter_->InputDigit('0', &result_));
 500 }
 501
 502 TEST_F(AsYouTypeFormatterTest, AYTF_NZMobile) {
 503   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::NZ()));
 504
 505   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 506   EXPECT_EQ("02", formatter_->InputDigit('2', &result_));
 507   EXPECT_EQ("021", formatter_->InputDigit('1', &result_));
 508   EXPECT_EQ("02-11", formatter_->InputDigit('1', &result_));
 509   EXPECT_EQ("02-112", formatter_->InputDigit('2', &result_));
 510   // Note the unittest is using fake metadata which might produce non-ideal
 511   // results.
 512   EXPECT_EQ("02-112 3", formatter_->InputDigit('3', &result_));
 513   EXPECT_EQ("02-112 34", formatter_->InputDigit('4', &result_));
 514   EXPECT_EQ("02-112 345", formatter_->InputDigit('5', &result_));
 515   EXPECT_EQ("02-112 3456", formatter_->InputDigit('6', &result_));
 516 }
 517
 518 TEST_F(AsYouTypeFormatterTest, AYTF_DE) {
 519   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::DE()));
 520
 521   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 522   EXPECT_EQ("03", formatter_->InputDigit('3', &result_));
 523   EXPECT_EQ("030", formatter_->InputDigit('0', &result_));
 524   EXPECT_EQ("030/1", formatter_->InputDigit('1', &result_));
 525   EXPECT_EQ("030/12", formatter_->InputDigit('2', &result_));
 526   EXPECT_EQ("030/123", formatter_->InputDigit('3', &result_));
 527   EXPECT_EQ("030/1234", formatter_->InputDigit('4', &result_));
 528
 529   // 08021 2345
 530   formatter_->Clear();
 531   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 532   EXPECT_EQ("08", formatter_->InputDigit('8', &result_));
 533   EXPECT_EQ("080", formatter_->InputDigit('0', &result_));
 534   EXPECT_EQ("080 2", formatter_->InputDigit('2', &result_));
 535   EXPECT_EQ("080 21", formatter_->InputDigit('1', &result_));
 536   EXPECT_EQ("08021 2", formatter_->InputDigit('2', &result_));
 537   EXPECT_EQ("08021 23", formatter_->InputDigit('3', &result_));
 538   EXPECT_EQ("08021 234", formatter_->InputDigit('4', &result_));
 539   EXPECT_EQ("08021 2345", formatter_->InputDigit('5', &result_));
 540
 541   // 00 1 650 253 2250
 542   formatter_->Clear();
 543   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 544   EXPECT_EQ("00", formatter_->InputDigit('0', &result_));
 545   EXPECT_EQ("00 1 ", formatter_->InputDigit('1', &result_));
 546   EXPECT_EQ("00 1 6", formatter_->InputDigit('6', &result_));
 547   EXPECT_EQ("00 1 65", formatter_->InputDigit('5', &result_));
 548   EXPECT_EQ("00 1 650", formatter_->InputDigit('0', &result_));
 549   EXPECT_EQ("00 1 650 2", formatter_->InputDigit('2', &result_));
 550   EXPECT_EQ("00 1 650 25", formatter_->InputDigit('5', &result_));
 551   EXPECT_EQ("00 1 650 253", formatter_->InputDigit('3', &result_));
 552   EXPECT_EQ("00 1 650 253 2", formatter_->InputDigit('2', &result_));
 553   EXPECT_EQ("00 1 650 253 22", formatter_->InputDigit('2', &result_));
 554   EXPECT_EQ("00 1 650 253 222", formatter_->InputDigit('2', &result_));
 555   EXPECT_EQ("00 1 650 253 2222", formatter_->InputDigit('2', &result_));
 556 }
 557
 558 TEST_F(AsYouTypeFormatterTest, AYTF_AR) {
 559   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::AR()));
 560
 561   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 562   EXPECT_EQ("01", formatter_->InputDigit('1', &result_));
 563   EXPECT_EQ("011", formatter_->InputDigit('1', &result_));
 564   EXPECT_EQ("011 7", formatter_->InputDigit('7', &result_));
 565   EXPECT_EQ("011 70", formatter_->InputDigit('0', &result_));
 566   EXPECT_EQ("011 703", formatter_->InputDigit('3', &result_));
 567   EXPECT_EQ("011 7031", formatter_->InputDigit('1', &result_));
 568   EXPECT_EQ("011 7031-3", formatter_->InputDigit('3', &result_));
 569   EXPECT_EQ("011 7031-30", formatter_->InputDigit('0', &result_));
 570   EXPECT_EQ("011 7031-300", formatter_->InputDigit('0', &result_));
 571   EXPECT_EQ("011 7031-3000", formatter_->InputDigit('0', &result_));
 572 }
 573
 574 TEST_F(AsYouTypeFormatterTest, AYTF_ARMobile) {
 575   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::AR()));
 576
 577   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 578   EXPECT_EQ("+5", formatter_->InputDigit('5', &result_));
 579   EXPECT_EQ("+54 ", formatter_->InputDigit('4', &result_));
 580   EXPECT_EQ("+54 9", formatter_->InputDigit('9', &result_));
 581   EXPECT_EQ("+54 91", formatter_->InputDigit('1', &result_));
 582   EXPECT_EQ("+54 9 11", formatter_->InputDigit('1', &result_));
 583   EXPECT_EQ("+54 9 11 2", formatter_->InputDigit('2', &result_));
 584   EXPECT_EQ("+54 9 11 23", formatter_->InputDigit('3', &result_));
 585   EXPECT_EQ("+54 9 11 231", formatter_->InputDigit('1', &result_));
 586   EXPECT_EQ("+54 9 11 2312", formatter_->InputDigit('2', &result_));
 587   EXPECT_EQ("+54 9 11 2312 1", formatter_->InputDigit('1', &result_));
 588   EXPECT_EQ("+54 9 11 2312 12", formatter_->InputDigit('2', &result_));
 589   EXPECT_EQ("+54 9 11 2312 123", formatter_->InputDigit('3', &result_));
 590   EXPECT_EQ("+54 9 11 2312 1234", formatter_->InputDigit('4', &result_));
 591 }
 592
 593 TEST_F(AsYouTypeFormatterTest, AYTF_KR) {
 594   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::KR()));
 595
 596   // +82 51 234 5678
 597   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 598   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
 599   EXPECT_EQ("+82 ", formatter_->InputDigit('2', &result_));
 600   EXPECT_EQ("+82 5", formatter_->InputDigit('5', &result_));
 601   EXPECT_EQ("+82 51", formatter_->InputDigit('1', &result_));
 602   EXPECT_EQ("+82 51-2", formatter_->InputDigit('2', &result_));
 603   EXPECT_EQ("+82 51-23", formatter_->InputDigit('3', &result_));
 604   EXPECT_EQ("+82 51-234", formatter_->InputDigit('4', &result_));
 605   EXPECT_EQ("+82 51-234-5", formatter_->InputDigit('5', &result_));
 606   EXPECT_EQ("+82 51-234-56", formatter_->InputDigit('6', &result_));
 607   EXPECT_EQ("+82 51-234-567", formatter_->InputDigit('7', &result_));
 608   EXPECT_EQ("+82 51-234-5678", formatter_->InputDigit('8', &result_));
 609
 610   // +82 2 531 5678
 611   formatter_->Clear();
 612   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 613   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
 614   EXPECT_EQ("+82 ", formatter_->InputDigit('2', &result_));
 615   EXPECT_EQ("+82 2", formatter_->InputDigit('2', &result_));
 616   EXPECT_EQ("+82 25", formatter_->InputDigit('5', &result_));
 617   EXPECT_EQ("+82 2-53", formatter_->InputDigit('3', &result_));
 618   EXPECT_EQ("+82 2-531", formatter_->InputDigit('1', &result_));
 619   EXPECT_EQ("+82 2-531-5", formatter_->InputDigit('5', &result_));
 620   EXPECT_EQ("+82 2-531-56", formatter_->InputDigit('6', &result_));
 621   EXPECT_EQ("+82 2-531-567", formatter_->InputDigit('7', &result_));
 622   EXPECT_EQ("+82 2-531-5678", formatter_->InputDigit('8', &result_));
 623
 624   // +82 2 3665 5678
 625   formatter_->Clear();
 626   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 627   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
 628   EXPECT_EQ("+82 ", formatter_->InputDigit('2', &result_));
 629   EXPECT_EQ("+82 2", formatter_->InputDigit('2', &result_));
 630   EXPECT_EQ("+82 23", formatter_->InputDigit('3', &result_));
 631   EXPECT_EQ("+82 2-36", formatter_->InputDigit('6', &result_));
 632   EXPECT_EQ("+82 2-366", formatter_->InputDigit('6', &result_));
 633   EXPECT_EQ("+82 2-3665", formatter_->InputDigit('5', &result_));
 634   EXPECT_EQ("+82 2-3665-5", formatter_->InputDigit('5', &result_));
 635   EXPECT_EQ("+82 2-3665-56", formatter_->InputDigit('6', &result_));
 636   EXPECT_EQ("+82 2-3665-567", formatter_->InputDigit('7', &result_));
 637   EXPECT_EQ("+82 2-3665-5678", formatter_->InputDigit('8', &result_));
 638
 639   // 02-114
 640   formatter_->Clear();
 641   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 642   EXPECT_EQ("02", formatter_->InputDigit('2', &result_));
 643   EXPECT_EQ("021", formatter_->InputDigit('1', &result_));
 644   EXPECT_EQ("02-11", formatter_->InputDigit('1', &result_));
 645   EXPECT_EQ("02-114", formatter_->InputDigit('4', &result_));
 646
 647   // 02-1300
 648   formatter_->Clear();
 649   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 650   EXPECT_EQ("02", formatter_->InputDigit('2', &result_));
 651   EXPECT_EQ("021", formatter_->InputDigit('1', &result_));
 652   EXPECT_EQ("02-13", formatter_->InputDigit('3', &result_));
 653   EXPECT_EQ("02-130", formatter_->InputDigit('0', &result_));
 654   EXPECT_EQ("02-1300", formatter_->InputDigit('0', &result_));
 655
 656   // 011-456-7890
 657   formatter_->Clear();
 658   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 659   EXPECT_EQ("01", formatter_->InputDigit('1', &result_));
 660   EXPECT_EQ("011", formatter_->InputDigit('1', &result_));
 661   EXPECT_EQ("011-4", formatter_->InputDigit('4', &result_));
 662   EXPECT_EQ("011-45", formatter_->InputDigit('5', &result_));
 663   EXPECT_EQ("011-456", formatter_->InputDigit('6', &result_));
 664   EXPECT_EQ("011-456-7", formatter_->InputDigit('7', &result_));
 665   EXPECT_EQ("011-456-78", formatter_->InputDigit('8', &result_));
 666   EXPECT_EQ("011-456-789", formatter_->InputDigit('9', &result_));
 667   EXPECT_EQ("011-456-7890", formatter_->InputDigit('0', &result_));
 668
 669   // 011-9876-7890
 670   formatter_->Clear();
 671   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 672   EXPECT_EQ("01", formatter_->InputDigit('1', &result_));
 673   EXPECT_EQ("011", formatter_->InputDigit('1', &result_));
 674   EXPECT_EQ("011-9", formatter_->InputDigit('9', &result_));
 675   EXPECT_EQ("011-98", formatter_->InputDigit('8', &result_));
 676   EXPECT_EQ("011-987", formatter_->InputDigit('7', &result_));
 677   EXPECT_EQ("011-9876", formatter_->InputDigit('6', &result_));
 678   EXPECT_EQ("011-9876-7", formatter_->InputDigit('7', &result_));
 679   EXPECT_EQ("011-9876-78", formatter_->InputDigit('8', &result_));
 680   EXPECT_EQ("011-9876-789", formatter_->InputDigit('9', &result_));
 681   EXPECT_EQ("011-9876-7890", formatter_->InputDigit('0', &result_));
 682 }
 683
 684 TEST_F(AsYouTypeFormatterTest, AYTF_MX) {
 685   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::MX()));
 686
 687   // +52 800 123 4567
 688   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 689   EXPECT_EQ("+5", formatter_->InputDigit('5', &result_));
 690   EXPECT_EQ("+52 ", formatter_->InputDigit('2', &result_));
 691   EXPECT_EQ("+52 8", formatter_->InputDigit('8', &result_));
 692   EXPECT_EQ("+52 80", formatter_->InputDigit('0', &result_));
 693   EXPECT_EQ("+52 800", formatter_->InputDigit('0', &result_));
 694   EXPECT_EQ("+52 800 1", formatter_->InputDigit('1', &result_));
 695   EXPECT_EQ("+52 800 12", formatter_->InputDigit('2', &result_));
 696   EXPECT_EQ("+52 800 123", formatter_->InputDigit('3', &result_));
 697   EXPECT_EQ("+52 800 123 4", formatter_->InputDigit('4', &result_));
 698   EXPECT_EQ("+52 800 123 45", formatter_->InputDigit('5', &result_));
 699   EXPECT_EQ("+52 800 123 456", formatter_->InputDigit('6', &result_));
 700   EXPECT_EQ("+52 800 123 4567", formatter_->InputDigit('7', &result_));
 701
 702   // +52 55 1234 5678
 703   formatter_->Clear();
 704   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 705   EXPECT_EQ("+5", formatter_->InputDigit('5', &result_));
 706   EXPECT_EQ("+52 ", formatter_->InputDigit('2', &result_));
 707   EXPECT_EQ("+52 5", formatter_->InputDigit('5', &result_));
 708   EXPECT_EQ("+52 55", formatter_->InputDigit('5', &result_));
 709   EXPECT_EQ("+52 55 1", formatter_->InputDigit('1', &result_));
 710   EXPECT_EQ("+52 55 12", formatter_->InputDigit('2', &result_));
 711   EXPECT_EQ("+52 55 123", formatter_->InputDigit('3', &result_));
 712   EXPECT_EQ("+52 55 1234", formatter_->InputDigit('4', &result_));
 713   EXPECT_EQ("+52 55 1234 5", formatter_->InputDigit('5', &result_));
 714   EXPECT_EQ("+52 55 1234 56", formatter_->InputDigit('6', &result_));
 715   EXPECT_EQ("+52 55 1234 567", formatter_->InputDigit('7', &result_));
 716   EXPECT_EQ("+52 55 1234 5678", formatter_->InputDigit('8', &result_));
 717
 718   // +52 212 345 6789
 719   formatter_->Clear();
 720   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 721   EXPECT_EQ("+5", formatter_->InputDigit('5', &result_));
 722   EXPECT_EQ("+52 ", formatter_->InputDigit('2', &result_));
 723   EXPECT_EQ("+52 2", formatter_->InputDigit('2', &result_));
 724   EXPECT_EQ("+52 21", formatter_->InputDigit('1', &result_));
 725   EXPECT_EQ("+52 212", formatter_->InputDigit('2', &result_));
 726   EXPECT_EQ("+52 212 3", formatter_->InputDigit('3', &result_));
 727   EXPECT_EQ("+52 212 34", formatter_->InputDigit('4', &result_));
 728   EXPECT_EQ("+52 212 345", formatter_->InputDigit('5', &result_));
 729   EXPECT_EQ("+52 212 345 6", formatter_->InputDigit('6', &result_));
 730   EXPECT_EQ("+52 212 345 67", formatter_->InputDigit('7', &result_));
 731   EXPECT_EQ("+52 212 345 678", formatter_->InputDigit('8', &result_));
 732   EXPECT_EQ("+52 212 345 6789", formatter_->InputDigit('9', &result_));
 733
 734   // +52 1 55 1234 5678
 735   formatter_->Clear();
 736   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 737   EXPECT_EQ("+5", formatter_->InputDigit('5', &result_));
 738   EXPECT_EQ("+52 ", formatter_->InputDigit('2', &result_));
 739   EXPECT_EQ("+52 1", formatter_->InputDigit('1', &result_));
 740   EXPECT_EQ("+52 15", formatter_->InputDigit('5', &result_));
 741   EXPECT_EQ("+52 1 55", formatter_->InputDigit('5', &result_));
 742   EXPECT_EQ("+52 1 55 1", formatter_->InputDigit('1', &result_));
 743   EXPECT_EQ("+52 1 55 12", formatter_->InputDigit('2', &result_));
 744   EXPECT_EQ("+52 1 55 123", formatter_->InputDigit('3', &result_));
 745   EXPECT_EQ("+52 1 55 1234", formatter_->InputDigit('4', &result_));
 746   EXPECT_EQ("+52 1 55 1234 5", formatter_->InputDigit('5', &result_));
 747   EXPECT_EQ("+52 1 55 1234 56", formatter_->InputDigit('6', &result_));
 748   EXPECT_EQ("+52 1 55 1234 567", formatter_->InputDigit('7', &result_));
 749   EXPECT_EQ("+52 1 55 1234 5678", formatter_->InputDigit('8', &result_));
 750
 751   // +52 1 541 234 5678
 752   formatter_->Clear();
 753   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 754   EXPECT_EQ("+5", formatter_->InputDigit('5', &result_));
 755   EXPECT_EQ("+52 ", formatter_->InputDigit('2', &result_));
 756   EXPECT_EQ("+52 1", formatter_->InputDigit('1', &result_));
 757   EXPECT_EQ("+52 15", formatter_->InputDigit('5', &result_));
 758   EXPECT_EQ("+52 1 54", formatter_->InputDigit('4', &result_));
 759   EXPECT_EQ("+52 1 541", formatter_->InputDigit('1', &result_));
 760   EXPECT_EQ("+52 1 541 2", formatter_->InputDigit('2', &result_));
 761   EXPECT_EQ("+52 1 541 23", formatter_->InputDigit('3', &result_));
 762   EXPECT_EQ("+52 1 541 234", formatter_->InputDigit('4', &result_));
 763   EXPECT_EQ("+52 1 541 234 5", formatter_->InputDigit('5', &result_));
 764   EXPECT_EQ("+52 1 541 234 56", formatter_->InputDigit('6', &result_));
 765   EXPECT_EQ("+52 1 541 234 567", formatter_->InputDigit('7', &result_));
 766   EXPECT_EQ("+52 1 541 234 5678", formatter_->InputDigit('8', &result_));
 767 }
 768
 769 TEST_F(AsYouTypeFormatterTest, AYTF_International_Toll_Free) {
 770   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::US()));
 771   // +800 1234 5678
 772   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 773   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
 774   EXPECT_EQ("+80", formatter_->InputDigit('0', &result_));
 775   EXPECT_EQ("+800 ", formatter_->InputDigit('0', &result_));
 776   EXPECT_EQ("+800 1", formatter_->InputDigit('1', &result_));
 777   EXPECT_EQ("+800 12", formatter_->InputDigit('2', &result_));
 778   EXPECT_EQ("+800 123", formatter_->InputDigit('3', &result_));
 779   EXPECT_EQ("+800 1234", formatter_->InputDigit('4', &result_));
 780   EXPECT_EQ("+800 1234 5", formatter_->InputDigit('5', &result_));
 781   EXPECT_EQ("+800 1234 56", formatter_->InputDigit('6', &result_));
 782   EXPECT_EQ("+800 1234 567", formatter_->InputDigit('7', &result_));
 783   EXPECT_EQ("+800 1234 5678", formatter_->InputDigit('8', &result_));
 784 }
 785
 786 TEST_F(AsYouTypeFormatterTest, AYTF_MultipleLeadingDigitPatterns) {
 787   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::JP()));
 788
 789   // +81 50 2345 6789
 790   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 791   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
 792   EXPECT_EQ("+81 ", formatter_->InputDigit('1', &result_));
 793   EXPECT_EQ("+81 5", formatter_->InputDigit('5', &result_));
 794   EXPECT_EQ("+81 50", formatter_->InputDigit('0', &result_));
 795   EXPECT_EQ("+81 50 2", formatter_->InputDigit('2', &result_));
 796   EXPECT_EQ("+81 50 23", formatter_->InputDigit('3', &result_));
 797   EXPECT_EQ("+81 50 234", formatter_->InputDigit('4', &result_));
 798   EXPECT_EQ("+81 50 2345", formatter_->InputDigit('5', &result_));
 799   EXPECT_EQ("+81 50 2345 6", formatter_->InputDigit('6', &result_));
 800   EXPECT_EQ("+81 50 2345 67", formatter_->InputDigit('7', &result_));
 801   EXPECT_EQ("+81 50 2345 678", formatter_->InputDigit('8', &result_));
 802   EXPECT_EQ("+81 50 2345 6789", formatter_->InputDigit('9', &result_));
 803
 804   // +81 222 12 5678
 805   formatter_->Clear();
 806   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 807   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
 808   EXPECT_EQ("+81 ", formatter_->InputDigit('1', &result_));
 809   EXPECT_EQ("+81 2", formatter_->InputDigit('2', &result_));
 810   EXPECT_EQ("+81 22", formatter_->InputDigit('2', &result_));
 811   EXPECT_EQ("+81 22 2", formatter_->InputDigit('2', &result_));
 812   EXPECT_EQ("+81 22 21", formatter_->InputDigit('1', &result_));
 813   EXPECT_EQ("+81 2221 2", formatter_->InputDigit('2', &result_));
 814   EXPECT_EQ("+81 222 12 5", formatter_->InputDigit('5', &result_));
 815   EXPECT_EQ("+81 222 12 56", formatter_->InputDigit('6', &result_));
 816   EXPECT_EQ("+81 222 12 567", formatter_->InputDigit('7', &result_));
 817   EXPECT_EQ("+81 222 12 5678", formatter_->InputDigit('8', &result_));
 818
 819   // 011113
 820   formatter_->Clear();
 821   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 822   EXPECT_EQ("01", formatter_->InputDigit('1', &result_));
 823   EXPECT_EQ("011", formatter_->InputDigit('1', &result_));
 824   EXPECT_EQ("011 1", formatter_->InputDigit('1', &result_));
 825   EXPECT_EQ("011 11", formatter_->InputDigit('1', &result_));
 826   EXPECT_EQ("011113", formatter_->InputDigit('3', &result_));
 827
 828   // +81 3332 2 5678
 829   formatter_->Clear();
 830   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 831   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
 832   EXPECT_EQ("+81 ", formatter_->InputDigit('1', &result_));
 833   EXPECT_EQ("+81 3", formatter_->InputDigit('3', &result_));
 834   EXPECT_EQ("+81 33", formatter_->InputDigit('3', &result_));
 835   EXPECT_EQ("+81 33 3", formatter_->InputDigit('3', &result_));
 836   EXPECT_EQ("+81 3332", formatter_->InputDigit('2', &result_));
 837   EXPECT_EQ("+81 3332 2", formatter_->InputDigit('2', &result_));
 838   EXPECT_EQ("+81 3332 2 5", formatter_->InputDigit('5', &result_));
 839   EXPECT_EQ("+81 3332 2 56", formatter_->InputDigit('6', &result_));
 840   EXPECT_EQ("+81 3332 2 567", formatter_->InputDigit('7', &result_));
 841   EXPECT_EQ("+81 3332 2 5678", formatter_->InputDigit('8', &result_));
 842 }
 843
 844 TEST_F(AsYouTypeFormatterTest, AYTF_LongIDD_AU) {
 845   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::AU()));
 846   // 0011 1 650 253 2250
 847   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 848   EXPECT_EQ("00", formatter_->InputDigit('0', &result_));
 849   EXPECT_EQ("001", formatter_->InputDigit('1', &result_));
 850   EXPECT_EQ("0011", formatter_->InputDigit('1', &result_));
 851   EXPECT_EQ("0011 1 ", formatter_->InputDigit('1', &result_));
 852   EXPECT_EQ("0011 1 6", formatter_->InputDigit('6', &result_));
 853   EXPECT_EQ("0011 1 65", formatter_->InputDigit('5', &result_));
 854   EXPECT_EQ("0011 1 650", formatter_->InputDigit('0', &result_));
 855   EXPECT_EQ("0011 1 650 2", formatter_->InputDigit('2', &result_));
 856   EXPECT_EQ("0011 1 650 25", formatter_->InputDigit('5', &result_));
 857   EXPECT_EQ("0011 1 650 253", formatter_->InputDigit('3', &result_));
 858   EXPECT_EQ("0011 1 650 253 2", formatter_->InputDigit('2', &result_));
 859   EXPECT_EQ("0011 1 650 253 22", formatter_->InputDigit('2', &result_));
 860   EXPECT_EQ("0011 1 650 253 222", formatter_->InputDigit('2', &result_));
 861   EXPECT_EQ("0011 1 650 253 2222", formatter_->InputDigit('2', &result_));
 862
 863   // 0011 81 3332 2 5678
 864   formatter_->Clear();
 865   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 866   EXPECT_EQ("00", formatter_->InputDigit('0', &result_));
 867   EXPECT_EQ("001", formatter_->InputDigit('1', &result_));
 868   EXPECT_EQ("0011", formatter_->InputDigit('1', &result_));
 869   EXPECT_EQ("00118", formatter_->InputDigit('8', &result_));
 870   EXPECT_EQ("0011 81 ", formatter_->InputDigit('1', &result_));
 871   EXPECT_EQ("0011 81 3", formatter_->InputDigit('3', &result_));
 872   EXPECT_EQ("0011 81 33", formatter_->InputDigit('3', &result_));
 873   EXPECT_EQ("0011 81 33 3", formatter_->InputDigit('3', &result_));
 874   EXPECT_EQ("0011 81 3332", formatter_->InputDigit('2', &result_));
 875   EXPECT_EQ("0011 81 3332 2", formatter_->InputDigit('2', &result_));
 876   EXPECT_EQ("0011 81 3332 2 5", formatter_->InputDigit('5', &result_));
 877   EXPECT_EQ("0011 81 3332 2 56", formatter_->InputDigit('6', &result_));
 878   EXPECT_EQ("0011 81 3332 2 567", formatter_->InputDigit('7', &result_));
 879   EXPECT_EQ("0011 81 3332 2 5678", formatter_->InputDigit('8', &result_));
 880
 881   // 0011 244 250 253 222
 882   formatter_->Clear();
 883   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 884   EXPECT_EQ("00", formatter_->InputDigit('0', &result_));
 885   EXPECT_EQ("001", formatter_->InputDigit('1', &result_));
 886   EXPECT_EQ("0011", formatter_->InputDigit('1', &result_));
 887   EXPECT_EQ("00112", formatter_->InputDigit('2', &result_));
 888   EXPECT_EQ("001124", formatter_->InputDigit('4', &result_));
 889   EXPECT_EQ("0011 244 ", formatter_->InputDigit('4', &result_));
 890   EXPECT_EQ("0011 244 2", formatter_->InputDigit('2', &result_));
 891   EXPECT_EQ("0011 244 25", formatter_->InputDigit('5', &result_));
 892   EXPECT_EQ("0011 244 250", formatter_->InputDigit('0', &result_));
 893   EXPECT_EQ("0011 244 250 2", formatter_->InputDigit('2', &result_));
 894   EXPECT_EQ("0011 244 250 25", formatter_->InputDigit('5', &result_));
 895   EXPECT_EQ("0011 244 250 253", formatter_->InputDigit('3', &result_));
 896   EXPECT_EQ("0011 244 250 253 2", formatter_->InputDigit('2', &result_));
 897   EXPECT_EQ("0011 244 250 253 22", formatter_->InputDigit('2', &result_));
 898   EXPECT_EQ("0011 244 250 253 222", formatter_->InputDigit('2', &result_));
 899 }
 900
 901 TEST_F(AsYouTypeFormatterTest, AYTF_LongIDD_KR) {
 902   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::KR()));
 903   // 00300 1 650 253 2250
 904   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 905   EXPECT_EQ("00", formatter_->InputDigit('0', &result_));
 906   EXPECT_EQ("003", formatter_->InputDigit('3', &result_));
 907   EXPECT_EQ("0030", formatter_->InputDigit('0', &result_));
 908   EXPECT_EQ("00300", formatter_->InputDigit('0', &result_));
 909   EXPECT_EQ("00300 1 ", formatter_->InputDigit('1', &result_));
 910   EXPECT_EQ("00300 1 6", formatter_->InputDigit('6', &result_));
 911   EXPECT_EQ("00300 1 65", formatter_->InputDigit('5', &result_));
 912   EXPECT_EQ("00300 1 650", formatter_->InputDigit('0', &result_));
 913   EXPECT_EQ("00300 1 650 2", formatter_->InputDigit('2', &result_));
 914   EXPECT_EQ("00300 1 650 25", formatter_->InputDigit('5', &result_));
 915   EXPECT_EQ("00300 1 650 253", formatter_->InputDigit('3', &result_));
 916   EXPECT_EQ("00300 1 650 253 2", formatter_->InputDigit('2', &result_));
 917   EXPECT_EQ("00300 1 650 253 22", formatter_->InputDigit('2', &result_));
 918   EXPECT_EQ("00300 1 650 253 222", formatter_->InputDigit('2', &result_));
 919   EXPECT_EQ("00300 1 650 253 2222", formatter_->InputDigit('2', &result_));
 920 }
 921
 922 TEST_F(AsYouTypeFormatterTest, AYTF_LongNDD_KR) {
 923   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::KR()));
 924   // 08811-9876-7890
 925   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 926   EXPECT_EQ("08", formatter_->InputDigit('8', &result_));
 927   EXPECT_EQ("088", formatter_->InputDigit('8', &result_));
 928   EXPECT_EQ("0881", formatter_->InputDigit('1', &result_));
 929   EXPECT_EQ("08811", formatter_->InputDigit('1', &result_));
 930   EXPECT_EQ("08811-9", formatter_->InputDigit('9', &result_));
 931   EXPECT_EQ("08811-98", formatter_->InputDigit('8', &result_));
 932   EXPECT_EQ("08811-987", formatter_->InputDigit('7', &result_));
 933   EXPECT_EQ("08811-9876", formatter_->InputDigit('6', &result_));
 934   EXPECT_EQ("08811-9876-7", formatter_->InputDigit('7', &result_));
 935   EXPECT_EQ("08811-9876-78", formatter_->InputDigit('8', &result_));
 936   EXPECT_EQ("08811-9876-789", formatter_->InputDigit('9', &result_));
 937   EXPECT_EQ("08811-9876-7890", formatter_->InputDigit('0', &result_));
 938
 939   // 08500 11-9876-7890
 940   formatter_->Clear();
 941   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
 942   EXPECT_EQ("08", formatter_->InputDigit('8', &result_));
 943   EXPECT_EQ("085", formatter_->InputDigit('5', &result_));
 944   EXPECT_EQ("0850", formatter_->InputDigit('0', &result_));
 945   EXPECT_EQ("08500 ", formatter_->InputDigit('0', &result_));
 946   EXPECT_EQ("08500 1", formatter_->InputDigit('1', &result_));
 947   EXPECT_EQ("08500 11", formatter_->InputDigit('1', &result_));
 948   EXPECT_EQ("08500 11-9", formatter_->InputDigit('9', &result_));
 949   EXPECT_EQ("08500 11-98", formatter_->InputDigit('8', &result_));
 950   EXPECT_EQ("08500 11-987", formatter_->InputDigit('7', &result_));
 951   EXPECT_EQ("08500 11-9876", formatter_->InputDigit('6', &result_));
 952   EXPECT_EQ("08500 11-9876-7", formatter_->InputDigit('7', &result_));
 953   EXPECT_EQ("08500 11-9876-78", formatter_->InputDigit('8', &result_));
 954   EXPECT_EQ("08500 11-9876-789", formatter_->InputDigit('9', &result_));
 955   EXPECT_EQ("08500 11-9876-7890", formatter_->InputDigit('0', &result_));
 956 }
 957
 958 TEST_F(AsYouTypeFormatterTest, AYTF_LongNDD_SG) {
 959   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::SG()));
 960   // 777777 9876 7890
 961   EXPECT_EQ("7", formatter_->InputDigit('7', &result_));
 962   EXPECT_EQ("77", formatter_->InputDigit('7', &result_));
 963   EXPECT_EQ("777", formatter_->InputDigit('7', &result_));
 964   EXPECT_EQ("7777", formatter_->InputDigit('7', &result_));
 965   EXPECT_EQ("77777", formatter_->InputDigit('7', &result_));
 966   EXPECT_EQ("777777 ", formatter_->InputDigit('7', &result_));
 967   EXPECT_EQ("777777 9", formatter_->InputDigit('9', &result_));
 968   EXPECT_EQ("777777 98", formatter_->InputDigit('8', &result_));
 969   EXPECT_EQ("777777 987", formatter_->InputDigit('7', &result_));
 970   EXPECT_EQ("777777 9876", formatter_->InputDigit('6', &result_));
 971   EXPECT_EQ("777777 9876 7", formatter_->InputDigit('7', &result_));
 972   EXPECT_EQ("777777 9876 78", formatter_->InputDigit('8', &result_));
 973   EXPECT_EQ("777777 9876 789", formatter_->InputDigit('9', &result_));
 974   EXPECT_EQ("777777 9876 7890", formatter_->InputDigit('0', &result_));
 975 }
 976
 977 TEST_F(AsYouTypeFormatterTest, AYTF_ShortNumberFormattingFix_AU) {
 978   // For Australia, the national prefix is not optional when formatting.
 979   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::AU()));
 980
 981   // 1234567890 - For leading digit 1, the national prefix formatting rule has
 982   // first group only.
 983   EXPECT_EQ("1", formatter_->InputDigit('1', &result_));
 984   EXPECT_EQ("12", formatter_->InputDigit('2', &result_));
 985   EXPECT_EQ("123", formatter_->InputDigit('3', &result_));
 986   EXPECT_EQ("1234", formatter_->InputDigit('4', &result_));
 987   EXPECT_EQ("1234 5", formatter_->InputDigit('5', &result_));
 988   EXPECT_EQ("1234 56", formatter_->InputDigit('6', &result_));
 989   EXPECT_EQ("1234 567", formatter_->InputDigit('7', &result_));
 990   EXPECT_EQ("1234 567 8", formatter_->InputDigit('8', &result_));
 991   EXPECT_EQ("1234 567 89", formatter_->InputDigit('9', &result_));
 992   EXPECT_EQ("1234 567 890", formatter_->InputDigit('0', &result_));
 993
 994   // +61 1234 567 890 - Test the same number, but with the country code.
 995   formatter_->Clear();
 996   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
 997   EXPECT_EQ("+6", formatter_->InputDigit('6', &result_));
 998   EXPECT_EQ("+61 ", formatter_->InputDigit('1', &result_));
 999   EXPECT_EQ("+61 1", formatter_->InputDigit('1', &result_));
1000   EXPECT_EQ("+61 12", formatter_->InputDigit('2', &result_));
1001   EXPECT_EQ("+61 123", formatter_->InputDigit('3', &result_));
1002   EXPECT_EQ("+61 1234", formatter_->InputDigit('4', &result_));
1003   EXPECT_EQ("+61 1234 5", formatter_->InputDigit('5', &result_));
1004   EXPECT_EQ("+61 1234 56", formatter_->InputDigit('6', &result_));
1005   EXPECT_EQ("+61 1234 567", formatter_->InputDigit('7', &result_));
1006   EXPECT_EQ("+61 1234 567 8", formatter_->InputDigit('8', &result_));
1007   EXPECT_EQ("+61 1234 567 89", formatter_->InputDigit('9', &result_));
1008   EXPECT_EQ("+61 1234 567 890", formatter_->InputDigit('0', &result_));
1009
1010   // 212345678 - For leading digit 2, the national prefix formatting rule puts
1011   // the national prefix before the first group.
1012   formatter_->Clear();
1013   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
1014   EXPECT_EQ("02", formatter_->InputDigit('2', &result_));
1015   EXPECT_EQ("021", formatter_->InputDigit('1', &result_));
1016   EXPECT_EQ("02 12", formatter_->InputDigit('2', &result_));
1017   EXPECT_EQ("02 123", formatter_->InputDigit('3', &result_));
1018   EXPECT_EQ("02 1234", formatter_->InputDigit('4', &result_));
1019   EXPECT_EQ("02 1234 5", formatter_->InputDigit('5', &result_));
1020   EXPECT_EQ("02 1234 56", formatter_->InputDigit('6', &result_));
1021   EXPECT_EQ("02 1234 567", formatter_->InputDigit('7', &result_));
1022   EXPECT_EQ("02 1234 5678", formatter_->InputDigit('8', &result_));
1023
1024   // 212345678 - Test the same number, but without the leading 0.
1025   formatter_->Clear();
1026   EXPECT_EQ("2", formatter_->InputDigit('2', &result_));
1027   EXPECT_EQ("21", formatter_->InputDigit('1', &result_));
1028   EXPECT_EQ("212", formatter_->InputDigit('2', &result_));
1029   EXPECT_EQ("2123", formatter_->InputDigit('3', &result_));
1030   EXPECT_EQ("21234", formatter_->InputDigit('4', &result_));
1031   EXPECT_EQ("212345", formatter_->InputDigit('5', &result_));
1032   EXPECT_EQ("2123456", formatter_->InputDigit('6', &result_));
1033   EXPECT_EQ("21234567", formatter_->InputDigit('7', &result_));
1034   EXPECT_EQ("212345678", formatter_->InputDigit('8', &result_));
1035
1036   // +61 2 1234 5678 - Test the same number, but with the country code.
1037   formatter_->Clear();
1038   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
1039   EXPECT_EQ("+6", formatter_->InputDigit('6', &result_));
1040   EXPECT_EQ("+61 ", formatter_->InputDigit('1', &result_));
1041   EXPECT_EQ("+61 2", formatter_->InputDigit('2', &result_));
1042   EXPECT_EQ("+61 21", formatter_->InputDigit('1', &result_));
1043   EXPECT_EQ("+61 2 12", formatter_->InputDigit('2', &result_));
1044   EXPECT_EQ("+61 2 123", formatter_->InputDigit('3', &result_));
1045   EXPECT_EQ("+61 2 1234", formatter_->InputDigit('4', &result_));
1046   EXPECT_EQ("+61 2 1234 5", formatter_->InputDigit('5', &result_));
1047   EXPECT_EQ("+61 2 1234 56", formatter_->InputDigit('6', &result_));
1048   EXPECT_EQ("+61 2 1234 567", formatter_->InputDigit('7', &result_));
1049   EXPECT_EQ("+61 2 1234 5678", formatter_->InputDigit('8', &result_));
1050 }
1051
1052 TEST_F(AsYouTypeFormatterTest, AYTF_ShortNumberFormattingFix_KR) {
1053   // For Korea, the national prefix is not optional when formatting, and the
1054   // national prefix formatting rule doesn't consist of only the first group.
1055   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::KR()));
1056
1057   // 111
1058   EXPECT_EQ("1", formatter_->InputDigit('1', &result_));
1059   EXPECT_EQ("11", formatter_->InputDigit('1', &result_));
1060   EXPECT_EQ("111", formatter_->InputDigit('1', &result_));
1061
1062   // 114
1063   formatter_->Clear();
1064   EXPECT_EQ("1", formatter_->InputDigit('1', &result_));
1065   EXPECT_EQ("11", formatter_->InputDigit('1', &result_));
1066   EXPECT_EQ("114", formatter_->InputDigit('4', &result_));
1067
1068   // 131212345 - Test a mobile number without the national prefix. Even though
1069   // it is not an emergency number, it should be formatted as a block.
1070   formatter_->Clear();
1071   EXPECT_EQ("1", formatter_->InputDigit('1', &result_));
1072   EXPECT_EQ("13", formatter_->InputDigit('3', &result_));
1073   EXPECT_EQ("131", formatter_->InputDigit('1', &result_));
1074   EXPECT_EQ("1312", formatter_->InputDigit('2', &result_));
1075   EXPECT_EQ("13121", formatter_->InputDigit('1', &result_));
1076   EXPECT_EQ("131212", formatter_->InputDigit('2', &result_));
1077   EXPECT_EQ("1312123", formatter_->InputDigit('3', &result_));
1078   EXPECT_EQ("13121234", formatter_->InputDigit('4', &result_));
1079
1080   // +82 131-2-1234 - Test the same number, but with the country code.
1081   formatter_->Clear();
1082   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
1083   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
1084   EXPECT_EQ("+82 ", formatter_->InputDigit('2', &result_));
1085   EXPECT_EQ("+82 1", formatter_->InputDigit('1', &result_));
1086   EXPECT_EQ("+82 13", formatter_->InputDigit('3', &result_));
1087   EXPECT_EQ("+82 131", formatter_->InputDigit('1', &result_));
1088   EXPECT_EQ("+82 131-2", formatter_->InputDigit('2', &result_));
1089   EXPECT_EQ("+82 131-2-1", formatter_->InputDigit('1', &result_));
1090   EXPECT_EQ("+82 131-2-12", formatter_->InputDigit('2', &result_));
1091   EXPECT_EQ("+82 131-2-123", formatter_->InputDigit('3', &result_));
1092   EXPECT_EQ("+82 131-2-1234", formatter_->InputDigit('4', &result_));
1093 }
1094
1095 TEST_F(AsYouTypeFormatterTest, AYTF_ShortNumberFormattingFix_MX) {
1096   // For Mexico, the national prefix is optional when formatting.
1097   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::MX()));
1098
1099   // 911
1100   EXPECT_EQ("9", formatter_->InputDigit('9', &result_));
1101   EXPECT_EQ("91", formatter_->InputDigit('1', &result_));
1102   EXPECT_EQ("911", formatter_->InputDigit('1', &result_));
1103
1104   // 800 123 4567 - Test a toll-free number, which should have a formatting rule
1105   // applied to it even though it doesn't begin with the national prefix.
1106   formatter_->Clear();
1107   EXPECT_EQ("8", formatter_->InputDigit('8', &result_));
1108   EXPECT_EQ("80", formatter_->InputDigit('0', &result_));
1109   EXPECT_EQ("800", formatter_->InputDigit('0', &result_));
1110   EXPECT_EQ("800 1", formatter_->InputDigit('1', &result_));
1111   EXPECT_EQ("800 12", formatter_->InputDigit('2', &result_));
1112   EXPECT_EQ("800 123", formatter_->InputDigit('3', &result_));
1113   EXPECT_EQ("800 123 4", formatter_->InputDigit('4', &result_));
1114   EXPECT_EQ("800 123 45", formatter_->InputDigit('5', &result_));
1115   EXPECT_EQ("800 123 456", formatter_->InputDigit('6', &result_));
1116   EXPECT_EQ("800 123 4567", formatter_->InputDigit('7', &result_));
1117
1118   // +52 800 123 4567 - Test the same number, but with the country code.
1119   formatter_->Clear();
1120   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
1121   EXPECT_EQ("+5", formatter_->InputDigit('5', &result_));
1122   EXPECT_EQ("+52 ", formatter_->InputDigit('2', &result_));
1123   EXPECT_EQ("+52 8", formatter_->InputDigit('8', &result_));
1124   EXPECT_EQ("+52 80", formatter_->InputDigit('0', &result_));
1125   EXPECT_EQ("+52 800", formatter_->InputDigit('0', &result_));
1126   EXPECT_EQ("+52 800 1", formatter_->InputDigit('1', &result_));
1127   EXPECT_EQ("+52 800 12", formatter_->InputDigit('2', &result_));
1128   EXPECT_EQ("+52 800 123", formatter_->InputDigit('3', &result_));
1129   EXPECT_EQ("+52 800 123 4", formatter_->InputDigit('4', &result_));
1130   EXPECT_EQ("+52 800 123 45", formatter_->InputDigit('5', &result_));
1131   EXPECT_EQ("+52 800 123 456", formatter_->InputDigit('6', &result_));
1132   EXPECT_EQ("+52 800 123 4567", formatter_->InputDigit('7', &result_));
1133 }
1134
1135 TEST_F(AsYouTypeFormatterTest, AYTF_NoNationalPrefix) {
1136   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::IT()));
1137
1138   EXPECT_EQ("3", formatter_->InputDigit('3', &result_));
1139   EXPECT_EQ("33", formatter_->InputDigit('3', &result_));
1140   EXPECT_EQ("333", formatter_->InputDigit('3', &result_));
1141   EXPECT_EQ("333 3", formatter_->InputDigit('3', &result_));
1142   EXPECT_EQ("333 33", formatter_->InputDigit('3', &result_));
1143   EXPECT_EQ("333 333", formatter_->InputDigit('3', &result_));
1144 }
1145
1146 TEST_F(AsYouTypeFormatterTest, AYTF_NoNationalPrefixFormattingRule) {
1147   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::AO()));
1148
1149   EXPECT_EQ("3", formatter_->InputDigit('3', &result_));
1150   EXPECT_EQ("33", formatter_->InputDigit('3', &result_));
1151   EXPECT_EQ("333", formatter_->InputDigit('3', &result_));
1152   EXPECT_EQ("333 3", formatter_->InputDigit('3', &result_));
1153   EXPECT_EQ("333 33", formatter_->InputDigit('3', &result_));
1154   EXPECT_EQ("333 333", formatter_->InputDigit('3', &result_));
1155 }
1156
1157 TEST_F(AsYouTypeFormatterTest, AYTF_ShortNumberFormattingFix_US) {
1158   // For the US, an initial 1 is treated specially.
1159   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::US()));
1160
1161   // 101 - Test that the initial 1 is not treated as a national prefix.
1162   EXPECT_EQ("1", formatter_->InputDigit('1', &result_));
1163   EXPECT_EQ("10", formatter_->InputDigit('0', &result_));
1164   EXPECT_EQ("101", formatter_->InputDigit('1', &result_));
1165
1166   // 112 - Test that the initial 1 is not treated as a national prefix.
1167   formatter_->Clear();
1168   EXPECT_EQ("1", formatter_->InputDigit('1', &result_));
1169   EXPECT_EQ("11", formatter_->InputDigit('1', &result_));
1170   EXPECT_EQ("112", formatter_->InputDigit('2', &result_));
1171
1172   // 122 - Test that the initial 1 is treated as a national prefix.
1173   formatter_->Clear();
1174   EXPECT_EQ("1", formatter_->InputDigit('1', &result_));
1175   EXPECT_EQ("12", formatter_->InputDigit('2', &result_));
1176   EXPECT_EQ("1 22", formatter_->InputDigit('2', &result_));
1177 }
1178
1179 TEST_F(AsYouTypeFormatterTest, AYTF_ClearNDDAfterIDDExtraction) {
1180   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::KR()));
1181
1182   // Check that when we have successfully extracted an IDD, the previously
1183   // extracted NDD is cleared since it is no longer valid.
1184   EXPECT_EQ("0", formatter_->InputDigit('0', &result_));
1185   EXPECT_EQ("00", formatter_->InputDigit('0', &result_));
1186   EXPECT_EQ("007", formatter_->InputDigit('7', &result_));
1187   EXPECT_EQ("0070", formatter_->InputDigit('0', &result_));
1188   EXPECT_EQ("00700", formatter_->InputDigit('0', &result_));
1189   EXPECT_EQ("0", GetExtractedNationalPrefix());
1190
1191   // Once the IDD "00700" has been extracted, it no longer makes sense for the
1192   // initial "0" to be treated as an NDD.
1193   EXPECT_EQ("00700 1 ", formatter_->InputDigit('1', &result_));
1194   EXPECT_EQ("", GetExtractedNationalPrefix());
1195
1196   EXPECT_EQ("00700 1 2", formatter_->InputDigit('2', &result_));
1197   EXPECT_EQ("00700 1 23", formatter_->InputDigit('3', &result_));
1198   EXPECT_EQ("00700 1 234", formatter_->InputDigit('4', &result_));
1199   EXPECT_EQ("00700 1 234 5", formatter_->InputDigit('5', &result_));
1200   EXPECT_EQ("00700 1 234 56", formatter_->InputDigit('6', &result_));
1201   EXPECT_EQ("00700 1 234 567", formatter_->InputDigit('7', &result_));
1202   EXPECT_EQ("00700 1 234 567 8", formatter_->InputDigit('8', &result_));
1203   EXPECT_EQ("00700 1 234 567 89", formatter_->InputDigit('9', &result_));
1204   EXPECT_EQ("00700 1 234 567 890", formatter_->InputDigit('0', &result_));
1205   EXPECT_EQ("00700 1 234 567 8901", formatter_->InputDigit('1', &result_));
1206   EXPECT_EQ("00700123456789012", formatter_->InputDigit('2', &result_));
1207   EXPECT_EQ("007001234567890123", formatter_->InputDigit('3', &result_));
1208   EXPECT_EQ("0070012345678901234", formatter_->InputDigit('4', &result_));
1209   EXPECT_EQ("00700123456789012345", formatter_->InputDigit('5', &result_));
1210   EXPECT_EQ("007001234567890123456", formatter_->InputDigit('6', &result_));
1211   EXPECT_EQ("0070012345678901234567", formatter_->InputDigit('7', &result_));
1212 }
1213
1214 TEST_F(AsYouTypeFormatterTest,
1215        NumberPatternsBecomingInvalidShouldNotResultInDigitLoss) {
1216   formatter_.reset(phone_util_.GetAsYouTypeFormatter(RegionCode::CN()));
1217
1218   EXPECT_EQ("+", formatter_->InputDigit('+', &result_));
1219   EXPECT_EQ("+8", formatter_->InputDigit('8', &result_));
1220   EXPECT_EQ("+86 ", formatter_->InputDigit('6', &result_));
1221   EXPECT_EQ("+86 9", formatter_->InputDigit('9', &result_));
1222   EXPECT_EQ("+86 98", formatter_->InputDigit('8', &result_));
1223   EXPECT_EQ("+86 988", formatter_->InputDigit('8', &result_));
1224   EXPECT_EQ("+86 988 1", formatter_->InputDigit('1', &result_));
1225   // Now the number pattern is no longer valid because there are multiple
1226   // leading digit patterns; when we try again to extract a country code we
1227   // should ensure we use the last leading digit pattern, rather than the first
1228   // one such that it *thinks* it's found a valid formatting rule again.
1229   // https://github.com/googlei18n/libphonenumber/issues/437
1230   EXPECT_EQ("+8698812", formatter_->InputDigit('2', &result_));
1231   EXPECT_EQ("+86988123", formatter_->InputDigit('3', &result_));
1232   EXPECT_EQ("+869881234", formatter_->InputDigit('4', &result_));
1233   EXPECT_EQ("+8698812345", formatter_->InputDigit('5', &result_));
1234 }
1235
1236 }  // namespace phonenumbers
1237 }  // namespace i18n