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